Automatic building design modeling method and system combining LLM and MCP

Abstract

The invention discloses an automatic building design modeling method and system combining LLM and MCP, and a whole-process design management system from user demands to automatic modeling and then to intelligent drawing checking and knowledge updating is constructed through four core mechanisms of'native large model reasoning + local knowledge base constraint + MCP protocol driving + man-machine closed-loop drawing checking '. Compared with a traditional single Revit secondary development framework, the design degree of freedom, the generation accuracy, the operation automation, the continuous optimization capability and the like are remarkably improved.

Description

Technical Field

[0001] The present invention relates to the technical field of automated modeling of building information models, and particularly to a method and system for automated modeling of building design that combines an LLM and an MCP. Background Art

[0002] Traditional Revit modeling mainly relies on manual drawing or proprietary plugins based on secondary development. Such methods not only require writing a large number of scripts and extension modules, with a long development cycle and high maintenance costs, but also often require repetitive custom development when adapting to new functional requirements, making it difficult to quickly respond to design changes.

[0003] The prior art CN117688632A discloses a method for intelligent 3D modeling in SolidWorks based on AIGC. By fine-tuning a general large model (such as OpenAI Codex, ChatGPT-4), VB code scripts for SolidWorks are generated, and then the model construction is completed with the help of a Visual Studio-driven plugin. Although this solution utilizes the automation capabilities of the large model, it still relies on model fine-tuning and proprietary secondary development tools, making it difficult to achieve cross-platform reuse and full-process automation without manual intervention. The main problems are as follows: (1) High development and maintenance costs: Fine-tuning the model requires a large amount of computing resources, and proprietary plugins need to be repeatedly developed, tested, and upgraded for each software; (2) Lack of flexibility: Once the business scenario or software version changes, the existing models and plugins are often difficult to quickly adapt, with a slow response speed; (3) Dependence on manual transfer: The generated scripts still need to be manually imported into the target software through an IDE (Integrated Development Environment) or the command line, unable to achieve true "zero manual operation"; (4) Limited reliability: Simply fine-tuning the model is prone to "hallucination" outputs outside of industry specifications, lacking dynamic verification and compliance guarantees. Summary of the Invention

[0004] The present invention provides a method and system for automated modeling of building design that combines an LLM (Large Language Model) and an MCP (Model Context Protocol) to solve the above technical problems existing in traditional Revit modeling methods.

[0005] According to a first aspect, in one embodiment, a method for automated modeling of building design that combines an LLM and an MCP is provided. The method includes: Obtain the user's design requirements, retrieve relevant types of knowledge in the pre-created local knowledge base according to the user's design requirements, create a prompt based on the user's design requirements and the knowledge base retrieval results, and input the obtained prompt into the large language model to generate an MCP protocol instruction sequence that meets the design intent; Parse and distribute the instructions according to the generated MCP protocol instruction sequence, and gradually perform modeling by calling plugins to generate a preliminary building model or drawing, and review and optimize the obtained preliminary building model or drawing, and finally complete the automatic modeling based on the MCP protocol instructions.

[0006] Furthermore, the creation of the local knowledge base specifically includes: Knowledge acquisition, knowledge indexing and vectorization, and knowledge update; The knowledge acquisition includes: Automatically start the process of extracting entries from design specification documents, historical project codes, or plugin documents according to scheduled tasks or external events; Perform OCR (Optical Character Recognition) on scanned documents or image-based documents, extract key fields and perform structured processing, and at the same time annotate metadata; Add tags to each extraction record for subsequent quick positioning and retrieval; The knowledge indexing and vectorization include: Convert the text content into high-dimensional vectors and store them in the vector database to support fast semantic retrieval; Establish knowledge graph nodes and relationship edges according to the "component type - parameter - constraint" triple for structured query and rule reasoning; Combine the full-text retrieval and vector retrieval results, and use the Top-K aggregation and relevance ranking algorithms to improve the recall rate and accuracy; The knowledge update includes: Automatically identify new rules, abnormal cases, or optimization suggestions according to the feedback of the drawing review results; Import the extracted new entries into the knowledge base in a preset format and annotate the meta-information; Automatically trigger the incremental indexing process of the vector library and the knowledge graph after supplementation to ensure that new knowledge is immediately retrievable.

[0007] Furthermore, obtaining the user's design requirements and retrieving relevant types of knowledge in the pre-created local knowledge base according to the user's design requirements specifically includes: Extract keywords from the obtained user design requirements and identify the design intent; Based on the obtained keywords and design intent, perform a search in the local knowledge base. Quickly locate the knowledge entries containing the keywords according to the keywords, and preliminarily screen the search results in combination with the design intent. Prioritize and select the design specifications, historical cases, or standard requirements that are closely related to the design needs.

[0008] Furthermore, create a prompt based on the user's design requirements and the knowledge base search results, specifically including: Through template matching or statement generation logic, organically combine the obtained keywords, design intent, and knowledge points in the knowledge base to create an optimized prompt, ensuring that the prompt can completely convey the design requirements and clearly guide the large language model to generate the MCP protocol instruction sequence in the direction that conforms to the design intent and relevant specification standards.

[0009] Furthermore, input the obtained prompt into the large language model to generate the MCP protocol instruction sequence that conforms to the design intent, specifically including: Use the large language model to generate an initial text description containing the modeling operation steps; Perform grammar checking, semantic verification on the generated initial text, and adjust it according to the standard format of the MCP protocol instructions. Finally, generate the MCP protocol instruction sequence for describing the modeling operation steps to ensure the logic, integrity, and operability of the instruction sequence.

[0010] Furthermore, perform instruction parsing and distribution according to the generated MCP protocol instruction sequence, and gradually perform modeling by calling plugins to generate a preliminary building model or drawing, specifically including: After obtaining the MCP protocol instruction sequence, perform syntax and semantic parsing on the instructions, identify each operation step and relevant parameters in the instructions, and then distribute the instructions to the corresponding processing modules or plugin methods according to the type and content of the instructions; Based on the pre-created mapping table of instruction types and Revit-MCP plugin methods, look up the table according to the instruction type to find the corresponding Revit-MCP plugin method, ensuring that the correct Revit plugin function can be called to execute the instructions; According to the number and complexity of the instructions and the performance of Revit, divide the MCP protocol instruction sequence into multiple batches, and formulate the execution time and interval for each batch to avoid tool jamming caused by executing too many instructions at the same time; According to the batched MCP protocol instruction sequence, push each instruction to the local MCP server through the JSON-RPC protocol in turn, and transfer the instructions to the corresponding Revit plugin through the MCP server; The Revit plugin receives a JSON-RPC request from the MCP server, parses it, and extracts the command and relevant parameters of the instruction; According to the parsed command and parameters, corresponding modeling operations are performed in the model space of Revit, including creating, modifying, or deleting components or elements; After each instruction is executed by the Revit plugin, it checks whether the operation is successful. If successful, relevant information is recorded. If failed, error information is captured and recorded, and then the execution result information is sent back to the MCP server through the JSON-RPC protocol and finally reaches the MCP scheduling layer; After a series of instructions are executed, a preliminary building model or drawing is generated.

[0011] Furthermore, the obtained preliminary building model or drawing is reviewed and optimized, specifically including: Using a rule engine to perform compliance checks on the generated model or drawing according to predefined design specifications and rules to verify whether it meets the design specifications; According to the preliminary building model or drawing and the compliance check report, using a large language model to conduct semantic review on the preliminary model and put forward optimization suggestions; The review results are fed back to the user, and the local knowledge base is updated to enhance the continuous learning ability of the system.

[0012] According to the second aspect, an embodiment provides an automated building design modeling system combining LLM and MCP, and the system includes: An AI interaction platform for obtaining user design requirements, retrieving various relevant knowledge in a pre-created local knowledge base according to user design requirements, creating a prompt according to user design requirements and the knowledge base retrieval results, and inputting the obtained prompt into a large language model to generate an MCP protocol instruction sequence that meets the design intent; An MCP service call driver for parsing and distributing instructions according to the generated MCP protocol instruction sequence, gradually performing modeling by calling a plugin to generate a preliminary building model or drawing, and reviewing and optimizing the obtained preliminary building model or drawing, and finally completing automatic modeling based on the MCP protocol instruction.

[0013] Furthermore, the core components used by the MCP service call driver include: Component mcp-srv: An MCP protocol server that bridges the AI interaction platform and the Revit plugin, responsible for receiving instructions from the AI interaction platform and forwarding them to the Revit plugin through Socket; Component mcp-cmd: As a dynamic link library resource DLL with a "function instruction set", it is loaded and used by the plug-in side mcp-addin; Component mcp-addin: As a Revit MCP plug-in, an external application in Revit, responsible for loading the command set, establishing communication, and executing commands; The AI interaction platform converts the user's design requirements into requests that conform to the MCP protocol according to preset rules or algorithms, and sends the MCP requests to mcp-srv; mcp-srv receives the MCP requests from the AI interaction platform, parses the request content, determines the plug-ins and functions to be called, and generates corresponding Socket messages and sends them to mcp-addin; mcp-addin receives the Socket messages from mcp-srv, and according to the message content, triggers an ExternalEvent (external event) to call the instructions in the corresponding command set DLL; The instructions in the DLL execute specific modeling operations in the Revit application by calling the Revit API. After the modeling operations are completed, the Revit application feeds back the execution results to mcp-addin; mcp-addin processes and encapsulates the execution results, generates a Socket response, and sends the Socket response to mcp-srv; mcp-srv receives the Socket response from the plug-in, parses and processes the Socket response content, generates a response that conforms to the MCP protocol, and sends it to the AI interaction platform.

[0014] According to a third aspect, in one embodiment, an electronic device is provided, and the device includes: a processor and a memory; The memory is used to store one or more program instructions; The processor is used to run one or more program instructions to execute the steps of an architectural design automation modeling method combining LLM and MCP as described in any one of the above.

[0015] According to a fourth aspect, in one embodiment, a computer-readable storage medium is provided. A computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the steps of an architectural design automation modeling method combining LLM and MCP as described in any one of the above are implemented.

[0016] The present invention provides a building design automation modeling method and system that combines LLM and MCP. Through four core mechanisms, namely "native large model inference + local knowledge base constraint + MCP protocol drive + human-machine closed-loop drawing review", a full-process design management system is constructed from user requirements to automatic modeling, then to intelligent drawing review and knowledge update. Compared with the traditional single Revit secondary development framework, the present invention has achieved significant improvements in terms of design freedom, generation accuracy, operation automation, and continuous optimization ability. Specifically, it has the following beneficial effects: (1) Driven by natural language, with higher design freedom Intuitive interaction: Users can directly issue modeling instructions through natural language, without the need to master cumbersome APIs (Application Programming Interfaces) or script syntax, significantly reducing the usage threshold and learning cost; Highly flexible: The LLM can instantly understand and respond to diverse requirements (such as "create a three-story frame structure and automatically arrange beams and columns"), supporting the choreography of composite instructions across different specialties and scenarios; Collaboration efficiency: The multi-agent collaborative modeling method based on the LLM can accelerate the design iteration and strengthen the real-time data exchange and problem-solving ability of adaptability.

[0017] (2) Local knowledge base, significantly reducing the hallucination rate Guarantee of authenticity: Integrate internal specification documents and historical cases, and strictly constrain the LLM generation process within the scope of verifiable knowledge through Retrieval-augmented Generation (RAG) technology, significantly reducing "fabrication" errors; Improvement of compliance: Conduct structured vector indexing for the regulations, standards, and internal company processes in the construction industry, and can real-time verify whether the output model meets various constraint conditions; Advanced prompt optimization: Combine advanced RAG technologies such as Chain-of-Thought (CoT) and Chain-of-Verification (CoVe) to further ensure the logic and accuracy of the generation results.

[0018] (3) MCP protocol, seamlessly achieving full automation drive Protocol unification: MCP provides a set of standard instruction formats based on JSON-RPC, enabling the LLM to issue consistent modeling commands across tools (such as Revit, AutoCAD); Transcription-free operation: Through the MCP protocol server, the JSON instructions output by the LLM can be directly sent to each tool plugin without manual writing or copying and pasting scripts; Strong scalability: As the MCP ecosystem matures, more professional software and data sources can be plugged and played, avoiding the need to repeatedly develop interfaces for each new tool. Brief Description of the Drawings

[0019] Figure 1 A flowchart of a method for automated building design modeling combining LLM and MCP provided by an embodiment of the present invention; Figure 2 A flowchart of generating MCP instructions by combining LLM with a local knowledge base in a method for automated building design modeling combining LLM and MCP provided by an embodiment of the present invention; Figure 3 A flowchart of automatic Revit modeling based on MCP protocol instructions in a method for automated building design modeling combining LLM and MCP provided by an embodiment of the present invention; Figure 4 A modeling example in a method for automated building design modeling combining LLM and MCP provided by an embodiment of the present invention. Detailed Description of the Embodiment

[0020] The present invention will be further described in detail below through specific embodiments in conjunction with the accompanying drawings. Similar elements in different embodiments are labeled with related similar element numbers. In the following embodiments, many detailed descriptions are provided to enable a better understanding of the present invention. However, those skilled in the art can easily recognize that some of the features can be omitted in different situations, or can be replaced by other elements, materials, or methods. In some cases, some operations related to the present invention are not shown or described in the specification to avoid overwhelming the core part of the present invention with excessive descriptions. For those skilled in the art, it is not necessary to describe these related operations in detail, and they can fully understand the related operations based on the descriptions in the specification and general technical knowledge in the field.

[0021] In addition, the features, operations, or characteristics described in the specification can be combined in any appropriate manner to form various embodiments. At the same time, the steps or actions in the method description can also be reordered or adjusted in an obvious manner by those skilled in the art. Therefore, the various sequences in the specification and drawings are only for clearly describing a certain embodiment and do not mean a necessary sequence unless otherwise stated that a certain sequence must be followed.

[0022] A method for automated building design modeling combining LLM and MCP provided by an embodiment of the present invention will be described in detail below in conjunction with Figure 1 for detailed description.

[0023] This embodiment consists of two major application programs: (1) Visualized LLM Interaction Program (hereinafter referred to as the AI Interaction Platform): Responsible for receiving user input, knowledge retrieval, prompt optimization, and interaction with large language models.

[0024] Core functions include local knowledge base management, Prompt assembly, multi-round context maintenance, etc.

[0025] After the user completes the construction of the local knowledge base system, the "AI Interaction Platform" undertakes all design interaction tasks of the large language model. Its core responsibility is: through a retrieval-enhanced Prompt generation mechanism, dynamically combine the user's natural language requirements with the specifications and cases in the local knowledge base, output optimized MCP instructions, significantly reduce the model hallucination risk, and directly drive the backend modeling tool.

[0026] The "AI Interaction Platform" draws on the interactive design of the ChatGPT web version. Users can conduct natural language conversations and model calls through the browser without writing command lines. Model inference and data processing are both completed in the local environment without any cloud dependencies, ensuring data privacy and response speed.

[0027] Its main functions are as follows: 1. Multi-model backend adaptation: Support mainstream LLMs such as Ollama, OpenAI API, Claude, etc., and switch as needed for seamless docking.

[0028] 2. Knowledge retrieval and Prompt optimization.

[0029] 3. Semantically parse the user input and retrieve the specification clauses, historical cases, and graph nodes in the local knowledge base.

[0030] 4. Integrate the retrieval results with the structured template to dynamically generate high-quality Prompts, significantly reducing hallucinations.

[0031] 5. Conversation management and template library.

[0032] 6. Automatically label the conversation topic, support session saving and restoration, and facilitate cross-project tracking.

[0033] 7. Built-in Prompt templates for multiple scenarios such as architecture, structure, and mechanical and electrical, which can be applied with one key to accelerate startup.

[0034] 8. Transparent integration of MCP Proxy (abbreviation: mcpo).

[0035] 9. Convert the JSON-RPC of the MCP protocol into a standard OpenAPI (RESTful) interface without modifying the existing tools.

[0036] 10. Plug and Play: After starting mcpo, any server that complies with the MCP specification can be immediately called within the platform.

[0037] 11. With the help of mcpo, any MCP can be connected to the "Interactive Platform" and generate powerful synergistic effects with the LLM and third-party applications.

[0038] 12. Due to the mcpo function of the interactive platform, the RevitMCP tool can be connected to the "AI Interactive Platform", and with the help of the local knowledge base system, the LLM is used to generate MCP instructions.

[0039] (2) MCP Service Invocation Driver: Responsible for parsing, scheduling, and distributing the MCP instruction set output by the LLM to specific BIM tools (such as Revit).

[0040] The core functions include MCP instruction compilation, JSON-RPC service management, instruction batch and rhythm control, execution result feedback, etc.

[0041] The two cooperate to form a closed-loop "Design Management System" to achieve the full-process automation of "user requirements → knowledge retrieval → hint optimization → model reasoning → MCP scheduling → tool modeling → drawing review feedback".

[0042] Core Module Description: 1. Visual LLM Interaction Program 1.1 Web Front-End Interaction Interface Function: Receive user natural language requirements, display progress, and visualize drawing review results.

[0043] Technology Stack: React / Vue + RESTful API.

[0044] 1.2 Local Knowledge Base Management System Document Collection: Automatically import intranet design specification documents and historical project design files.

[0045] Knowledge Graph Construction: Organize the "component - parameter - constraint" relationship in a node / edge manner and support rule queries.

[0046] Vector Index: Vectorize text and graph nodes for fast semantic retrieval.

[0047] Retrieval Optimization: Aggregate Top-K results, generate summaries, and sort by context relevance.

[0048] 1.3 Hint Optimization Engine Intent Parsing: The NLP (Natural Language Processing) module parses the user's requirement intent in multiple rounds.

[0049] Prompt Generation: Integrate the user intent, specification fragments, and historical conversations to generate a structured Prompt.

[0050] Context Maintenance: Manage the conversation state, support segmented reuse and multitask switching.

[0051] 1.4 LLM Inference Interface Request Wrapping: Connect the optimized Prompt to large models such as DeepSeek through gRPC / REST.

[0052] Response Parsing: Pre-parse the natural language or JSON MCP instructions output by the LLM.

[0053] Among them, the specific content of the local knowledge base management system is as follows: Although the local knowledge base management system is an embedded subsystem of the "Visual LLM Interaction Platform" (hereinafter referred to as the "AI Interaction Platform"), it needs to be a pre-module of the system, responsible for the management of the knowledge base and the key to optimizing the large model prompts. Users need to pre-organize the company's internal design specifications, experience documents, and existing project data in advance, use the local knowledge base system to build a knowledge graph or embed a vector library, introduce documents such as internal design specifications and design experiences, and build a knowledge graph / semantic constraint.

[0054] The local knowledge base system is an open-source RAG engine built based on deep document understanding. It provides a set of streamlined RAG workflows, and combines large language models to provide reliable answers and well-founded references for users' various complex format data.

[0055] Its main functions are as follows: 1. Based on deep document understanding, it can extract key information from various complex format unstructured data.

[0056] 2. The text slicing process is visualized and supports manual adjustment.

[0057] 3. The answer provides a snapshot of the key reference and supports tracing back to the source, minimizing hallucinations to the greatest extent.

[0058] 4. Support compatibility with various file types, including Word documents, PPTs, excel tables, txt files, pictures, PDFs, etc.

[0059] 5. Support large language model LLM and vector model configuration.

[0060] 6. Based on multi-way recall and fusion re-ranking.

[0061] 7. Provide easy-to-use APIs that can be integrated into various third-party systems.

[0062] Overview of the Local Knowledge Base Management System Process: The local knowledge base management system consists of three sub-processes: knowledge acquisition, knowledge indexing and vectorization, and knowledge update. It forms a closed loop with the drawing review feedback link of the main program to continuously improve the content of the knowledge base. The specific process is described as follows: The First Stage: Knowledge Acquisition The First Step: Automatic Triggering. According to the scheduled task or external event, start the process of extracting entries from design specification documents (PDF, Word), historical project codes, and plugin documents.

[0063] The Second Step: OCR and Structuring. Perform OCR on scanned or imaged documents, extract key fields and perform structuring, and at the same time annotate metadata (such as version number, release date).

[0064] The Third Step: Metadata Management. Add tags (project, specialty, source) to each extraction record for subsequent quick positioning and retrieval.

[0065] The Second Stage: Knowledge Indexing and Vectorization The Fourth Step: Vectorized Storage. Convert text content such as specification clauses and experience points into high-dimensional vectors and store them in a vector database, such as FAISS (Facebook AI Similarity Search, an AI similarity search tool open-sourced by Facebook), to support fast semantic retrieval.

[0066] The Fifth Step: Knowledge Graph Construction. Establish graph nodes and relationship edges according to the "component type - parameter - constraint" triple for structured query and rule reasoning.

[0067] The Sixth Step: Retrieval Optimization. Combine the results of full-text retrieval and vector retrieval, and use the Top-K aggregation and relevance ranking algorithms to improve the recall rate and precision.

[0068] The Third Stage: Knowledge Update The Seventh Step: Drawing Review Feedback Extraction. Automatically identify new rules, abnormal cases, or optimization suggestions from the drawing review results and user modification records of the main program.

[0069] The Eighth Step: Knowledge Supplement. Import the extracted new entries into the knowledge base in a preset format and annotate meta-information such as source and time.

[0070] The Ninth Step: Index Triggering. After the supplement is completed, automatically trigger the incremental indexing process of the vector library and the graph to ensure that new knowledge is immediately retrievable.

[0071] 2. MCP Service Call Driver The "MCP Service Call Driver" (abbreviated as "Driver") in this embodiment is mainly written in C# and is an independently encapsulated Revit auxiliary program. It not only defines a series of core operation command sets for CRUD (Create, Retrieve, Update, Delete) of Revit elements, but also serves as a C# plug-in that can run within Revit. By loading the command set and implementing the logic of receiving, dispatching, and executing commands, Revit can truly execute the operations sent by AI.

[0072] 2.1 MCP Instruction Set Management Protocol Definition: Based on the command specification of JSON-RPC, define general modeling instructions (create / modify / delete components).

[0073] Instruction Compilation: Compile the high-level instruction text output by the LLM into a JSON object that conforms to the MCP Schema.

[0074] 2.2 MCP-Server Service Communication Management: Listen to the instruction queue from the LLM interface and maintain a two-way channel with the front end and tool plug-ins.

[0075] Security Verification: Verify user permissions, instruction legality, and rate limits.

[0076] 2.3 Instruction Scheduling and Rhythm Control Batching Strategy: Split instructions into several batches according to complexity and system load.

[0077] Rate Limit: Dynamically adjust the issuing frequency to avoid tool lag or network congestion.

[0078] 2.4 Tool Plug-in Adaptation Layer Revit-MCP Adapter: Receive MCP calls and map them to Revit API operations.

[0079] 2.5 Execution Feedback and Log Summary of Execution Results: Collect the success / failure status and error information of each instruction.

[0080] Real-time Monitoring Panel: Display the tool execution progress and exception alarms on the front end.

[0081] As Figure 1 shown, in step S100, obtain the user's design requirements, retrieve various relevant knowledge in the pre-created local knowledge base according to the user's design requirements, create a prompt Prompt in combination with the user's design requirements and the knowledge base retrieval results, and input the obtained prompt Prompt into the large language model to generate an MCP protocol instruction sequence that conforms to the design intention.

[0082] like Figure 2 As shown, the following is a detailed description of the steps for generating MCP instructions using LLM combined with a local knowledge base: S110: User input requirements Input: Users input design requirements into the system through natural language, such as "design a conference room layout that can accommodate 500 people."

[0083] Output: The system receives the text message and there is no other additional output.

[0084] Logical association: This is the starting point of the entire process. The user input requirements provide the basis and direction for all subsequent operations.

[0085] S120: The system receives and displays preliminary feedback Input: Receive the design requirement text entered by the user in the previous step.

[0086] Output: The system displays preliminary feedback to the user, such as simple prompts such as "We have received your conference room layout design requirements and are processing them for you."

[0087] Logical association: Indicates to users that the system has started working, serves as an interactive connection, and prevents users from being uncertain whether the system is running due to lack of feedback.

[0088] S130: Extract keywords and identify design intent Input: Natural language design requirements entered by the user, such as "design a conference room layout that can accommodate 500 people."

[0089] Output: Extracted keywords such as "500 people", "conference room", "layout", etc., and the identified design intent is to design the conference room space layout, focusing on the design requirements related to the number of people accommodated.

[0090] Intermediate computational process: The system uses natural language processing technology to perform lexical and syntactic analysis on the input text, mining keywords and intent through semantic understanding. This may involve using pre-trained language models to extract text features and perform pattern recognition, thereby accurately grasping the core points of user needs.

[0091] Logical association: Accurate keyword extraction and design intent identification are the key to subsequently retrieving effective information from the local knowledge base. Only by clarifying the user's true needs can we obtain useful knowledge from the knowledge base in a targeted manner.

[0092] S140: Local Knowledge Base Search Input: Keywords extracted in the previous step, such as "conference room", "layout", "capacity", etc., as well as the identified design intent.

[0093] Output: Retrieve design specifications related to meeting room layout design (such as meeting room space planning standards, safety passage requirements, etc.), historical cases (previous successful or typical meeting room layout design solutions), and standard requirements (including applicable requirements of building codes, fire codes, etc. in meeting room design) from the local knowledge base.

[0094] Intermediate calculation process: The local knowledge base uses retrieval techniques such as inverted indexing to quickly locate knowledge entries containing these keywords based on the keywords, and preliminarily screens the retrieval results in combination with the design intent, giving priority to selecting various knowledge resources closely related to meeting room layout design.

[0095] Logical association: The local knowledge base provides rich background knowledge and practical experience support for the entire instruction generation process. These retrieval results will be used as materials for constructing optimization prompts (Prompts) and integrated into the subsequent guidance of the large language model, enabling it to generate more practical MCP instructions based on accurate and relevant information.

[0096] S150: Construct an optimized prompt (Prompt) Input: Extracted keywords, design intent, and relevant design specifications, historical cases, and standard requirements retrieved from the local knowledge base, etc.

[0097] Output: Construct an optimized prompt, such as "Design a meeting room layout that can accommodate 500 people according to the meeting room design specifications, referring to previous successful large meeting room cases, and meeting the requirements of fire protection standards and maximum space utilization", etc., to form context-rich and highly targeted prompt information.

[0098] Intermediate calculation process: Through certain template matching or statement generation logic, the keywords, design intent, and knowledge points in the knowledge base are organically combined to ensure that the prompt information can fully convey the design requirements and clearly guide the large language model to generate an instruction sequence in the direction consistent with the design intent and relevant specification standards. This may involve further processing and collation of the retrieval results to integrate scattered knowledge points into a coherent and logical prompt statement.

[0099] Logical association: This optimized prompt plays a bridging role by integrating various types of information obtained previously and presenting it in a form that is easy for the large language model to understand and process, thus providing strong guidance for generating high-quality MCP instructions.

[0100] S160: Input the prompt into the native large language model Input: The optimized prompt constructed above, such as "Design a meeting room layout that can accommodate 500 people according to the meeting room design specifications. Refer to previous successful large meeting room cases and meet the requirements of fire safety standards and maximum space utilization."

[0101] Output: The native large language model (such as DeepSeek) receives this prompt and starts to perform computational processing based on its internal training knowledge and model architecture.

[0102] Intermediate calculation process: The native large language model uses its vast amount of training data and complex neural network structure to perform semantic understanding and knowledge association on the prompt, generating corresponding text outputs. It will, according to the requirements in the prompt, combine its own knowledge of aspects such as building layout and space planning, and think about how to construct the steps for the meeting room layout that meets the requirements. For example, it starts to plan the seating arrangement and determine the position of the podium and other preliminary modeling operation steps.

[0103] Logical association: The native large language model is the core engine for generating the final MCP instructions. It uses its powerful language generation ability to transform the previously optimized and integrated prompt into a specific sequence of executable modeling operation steps, thus realizing the transformation from requirements to actual executable instructions.

[0104] S170: Generate an MCP instruction sequence Input: The initial text information generated by the native large language model according to the prompt, such as some operation suggestions or step descriptions regarding the meeting room layout.

[0105] Output: An MCP instruction sequence that conforms to the design intent, specifically describing the operation steps for constructing the meeting room layout model. For example: "Step 1: Draw a rough outline of the meeting room; Step 2: Determine the area of the seating area according to the requirement of accommodating 500 people and the space standard per person; Step 3: Reasonably arrange the positions of the aisles in the seating area to meet the fire evacuation requirements; Step 4: Set the position of the podium to ensure good visibility and a coordinated layout with the seating area" and a series of detailed modeling instruction sequences.

[0106] Intermediate calculation process: Further screen, organize, and optimize the text generated by the native large language model to ensure the logic, integrity, and operability of the instruction sequence. This may involve operations such as grammar checking, semantic verification of the generated text, and adjustment according to the standard format of MCP instructions, so that it can accurately guide the subsequent modeling work.

[0107] Logical association: This is the final output link of the entire process. The generated MCP instruction sequence will be directly applied to the actual modeling operation, realizing the transformation from user design requirements to specific model construction steps, providing a clear operation guide for the entire modeling process, and completing the task goal from requirement input to instruction generation.

[0108] As Figure 1 shown, in step S200, the instruction parsing and distribution are performed according to the generated MCP protocol instruction sequence, and the modeling is gradually carried out by calling the plug-ins to generate a preliminary building model or drawing, and the obtained preliminary building model or drawing is reviewed and optimized, and finally the automatic modeling based on the MCP protocol instruction is completed.

[0109] As Figure 3 shown, the following is a detailed discussion of the Revit automatic modeling process based on the MCP protocol instruction: S210: Receive and execute the MCP instruction, instruction parsing and distribution.

[0110] Input: MCP instruction sequence, such as the instruction sequence about the conference room layout generated from the previous process: "Design a conference room layout that can accommodate 500 people, and the floor area per person should meet the requirement of 1.5 square meters..." Output: Parsed instructions and distributed instruction sequence.

[0111] Intermediate calculation process: After the system receives the MCP instruction, it first parses the syntax and semantics of the instruction to identify each operation step and related parameters in the instruction, such as specific requirements for seat arrangement, aisle width, podium position, etc. in the conference room layout design. Then, according to the type and content of the instruction, the instruction is distributed to the corresponding processing module or plug-in method.

[0112] Logical association: This is the starting point of the entire automatic modeling process, ensuring that subsequent operations can be accurately executed according to the instructions.

[0113] S220: Look up the corresponding Revit-MCP plug-in method according to the instruction type in the table.

[0114] Input: Parsed MCP instruction, such as "Draw the general outline of the conference room and determine its length and width dimensions...".

[0115] Output: Corresponding Revit-MCP plug-in method, such as "Revit-Create-Room-Outline".

[0116] Intermediate calculation process: The system internally maintains a mapping table between instruction types and Revit-MCP plug-in methods. By looking up this table, the corresponding plug-in method is found according to the instruction type (such as drawing the outline, arranging seats, etc.).

[0117] Logical association: It provides a methodological basis for subsequent specific modeling operations, ensuring that the correct Revi plugin functions can be called to execute instructions.

[0118] S230: To avoid tool lag, batch and rhythm control are performed on the instructions.

[0119] Input: The sequence of MCP instructions to be executed.

[0120] Output: The batched instruction sequence and the execution rhythm plan.

[0121] Intermediate calculation process: According to the number and complexity of the instructions, as well as the performance of Revit, the instruction sequence is divided into multiple batches, and the execution time and interval for each batch are determined to avoid tool lag caused by executing too many instructions simultaneously.

[0122] Logical association: Ensures the smoothness of the entire modeling process, improves the stability of the system and the user experience.

[0123] S240: Each instruction is sequentially pushed to the local MCP server via JSON-RPC, and the server forwards it to the corresponding Revit plugin.

[0124] Input: The batched MCP instruction sequence.

[0125] Output: Instruction requests sent via the JSON-RPC protocol.

[0126] Intermediate calculation process: Each instruction is converted into a JSON-RPC formatted request, containing information such as the method name and parameters of the instruction, and then sequentially sent to the local MCP server, which in turn forwards the request to the corresponding Revit plugin.

[0127] Logical association: Realizes the transmission and invocation of instructions from the MCP system to the Revit plugin, providing technical support for subsequent modeling operations.

[0128] S250: The Revit plugin receives the JSON-RPC and parses the command and parameters.

[0129] Input: The JSON-RPC instruction request from the MCP server.

[0130] Output: The parsed command and parameters.

[0131] Intermediate calculation process: After receiving the JSON-RPC request, the Revit plugin parses it to extract the command (such as creating a component, modifying properties, etc.) of the instruction and the relevant parameters (such as the type, size, location of the component, etc.).

[0132] Logical association: Prepare for subsequent specific operations in the Revit model to ensure that the plugin can correctly understand the requirements of the instructions.

[0133] S260: Create, modify, or delete components or elements in the model space Input: Parsed commands and parameters, such as "Create a meeting room outline, 30 meters long and 25 meters wide".

[0134] Output: Updated Revit model containing newly created, modified, or deleted components or elements.

[0135] Intermediate calculation process: Perform corresponding operations in the Revit model space according to the parsed commands and parameters. For example, use Revit's API to create a meeting room outline component of a specified size, or modify the properties of existing components, such as moving seat positions, adjusting aisle widths, etc.

[0136] Logical association: This is the actual modeling operation step, which transforms the instructions into specific model changes and gradually constructs a complete building model. As Figure 4 shown.

[0137] S270: Return the execution result (success / failure, error message) of each instruction to the MCP scheduling layer Input: The result after the instruction is executed, such as "Create meeting room outline successfully" or "Modify seat position failed, parameter error".

[0138] Output: Execution result information returned to the MCP scheduling layer.

[0139] Intermediate calculation process: After the Revit plugin executes each instruction, it checks whether the operation is successful. If successful, record relevant information; if failed, capture the error message and record it. Then, these information are returned to the MCP server through the JSON-RPC protocol and finally reach the MCP scheduling layer.

[0140] Logical association: Enable the MCP system to understand the execution status of the instructions in real time, process failed instructions in a timely manner or make corresponding adjustments to ensure the smooth progress of the entire modeling process.

[0141] S280: Generate a preliminary building model or drawing Input: The Revit model after a series of instructions are executed.

[0142] Output: A preliminary building model or drawing.

[0143] Intermediate calculation process: In Revit, generate a preliminary 3D building model or 2D drawing view based on the completed modeling operations. This may involve setting the display style of the view, adding annotations and dimensions, etc.

[0144] Logical association: Provides a basis for subsequent model checking and optimization, ensuring that the generated model meets the basic design requirements.

[0145] S290: The rule engine performs compliance checks on the generated model or drawing to verify compliance with the design specifications Input: Preliminary building model or drawing.

[0146] Output: Compliance check report indicating the parts of the model that comply and do not comply with the design specifications.

[0147] Intermediate calculation process: The rule engine automatically checks the model according to predefined design specifications and rules (such as building codes, fire codes, etc.). For example, check whether the evacuation passage width of the meeting room meets the minimum requirements and whether the seat arrangement meets the visual requirements, etc.

[0148] Logical association: Ensures that the generated model is correct in terms of design specifications, promptly discovers and corrects possible problems, and improves the quality and reliability of the model.

[0149] S2100: The large model conducts semantic review on the model and puts forward optimization suggestions Input: Preliminary building model or drawing and compliance check report.

[0150] Output: Optimization suggestions put forward by the large model, such as "It is recommended to adjust the seat arrangement in the meeting room to improve space utilization".

[0151] Intermediate calculation process: The large model combines its understanding of building knowledge and analysis of the model to identify possible areas for improvement. For example, by analyzing the layout and usage functions of the meeting room, it is recommended to adjust the seat arrangement to better utilize the space or optimize the passage design to improve the evacuation efficiency of personnel.

[0152] Logical association: Further improves the performance and quality of the model, making it more in line with the actual usage requirements and design intentions.

[0153] S2110: Feed back the review results to the user and update the local knowledge base to enhance the system's continuous learning ability Input: Optimization suggestions put forward by the large model and compliance check report.

[0154] Output: Review results and optimization suggestions fed back to the user, as well as the updated local knowledge base.

[0155] Intermediate calculation process: Organize the review results and optimization suggestions into a report that can be understood by users, and feedback it to users through the user interface. At the same time, record these review results and suggestions as new knowledge in the local knowledge base for reference and learning in future design and modeling processes.

[0156] Logical association: Achieved continuous improvement and learning of the system. By accumulating experience and knowledge, the accuracy and quality of automatic modeling are continuously improved, providing better services for users.

[0157] In this embodiment, the "driver" can achieve the technical purpose of driving Revit through LLM interaction, mainly relying on its core components: "mcp-srv", "mcp-cmd", and "mcp-addin", which together constitute an end-to-end solution based on MCP.

[0158] Component description: Component mcp-srv: As the Revit MCP protocol server, it bridges the MCP protocol server between the AI interaction platform and the Revit add-in. Specifically, the MCP server implemented in Node.js / TypeScript interfaces with the AI interaction platform, responsible for receiving AI instructions and forwarding them to Revit through Socket.

[0159] Component mcp-cmd: As the Revit MCP command set library, it defines and implements the core command library for operating on Revit elements. Specifically, the core command set library written in C# defines a series of operation commands for CRUD (Create, Retrieve, Update, Delete) of Revit elements, and is used as a dynamic link library resource (DLL) with a "function instruction set" to be loaded and used by the add-in side (mcp-addin).

[0160] Component mcp-addin: As the Revit MCP add-in, an external application in Revit, responsible for loading the command set, establishing communication, and executing commands. Specifically, a C# add-in running within Revit loads the command set (including mcp-cmd) and implements the logic to receive, schedule, and execute these commands, enabling Revit to truly execute the operations issued by AI. The interaction process between components is described as follows: The first step: The AI client sends a request Input: The user enters design requirements or operation instructions in the "AI interaction platform".

[0161] Intermediate calculation process: The "AI interaction platform" converts the user's input into a request that conforms to the MCP protocol according to preset rules or algorithms.

[0162] Output: Generate an MCP request and send it to mcp-srv.

[0163] Step 2: The MCP server receives the request Input: The MCP server receives an MCP request from the "AI Interaction Platform".

[0164] Intermediate calculation process: The server parses the request content, determines the required plug-ins and functions to be called, and generates corresponding Socket messages.

[0165] Output: Send a Socket message to mcp-addin.

[0166] Step 3: The plug-in triggers an ExternalEvent Input: mcp-addin receives a Socket message from the MCP server.

[0167] Intermediate calculation process: The plug-in triggers an ExternalEvent based on the message content to call the instructions in the corresponding command set DLL.

[0168] Output: Call the instructions in the mcp-cmd DLL through the ExternalEvent.

[0169] Step 4: Call the Revit API Input: The mcp-cmd DLL receives the trigger signal from the ExternalEvent.

[0170] Intermediate calculation process: The instructions in the DLL execute specific modeling operations by calling the Revit API.

[0171] Output: Execute the corresponding modeling operations in the Revit application and return the execution results.

[0172] Step 5: Feedback the execution results Input: After the Revit application finishes executing the modeling operations, it feeds back the execution results to mcp-addin.

[0173] Intermediate calculation process: The plug-in processes and encapsulates the execution results to generate a Socket response.

[0174] Output: Send a Socket response to the MCP server.

[0175] Step 6: The MCP server returns a response Input: The MCP server receives a Socket response from the plug-in.

[0176] Intermediate calculation process: The server parses and processes the response content to generate a response that conforms to the MCP protocol.

[0177] Output: Send an MCP response to the AI client Corresponding to the above-disclosed building design automation modeling method combining LLM and MCP, an embodiment of the present invention also discloses a building design automation modeling system combining LLM and MCP, which specifically includes: An AI interaction platform for obtaining user design requirements, retrieving various relevant knowledge in a pre-created local knowledge base according to the user design requirements, creating a prompt word Prompt by combining the user design requirements and the knowledge base retrieval results, and inputting the obtained prompt word Prompt into a large language model to generate an MCP protocol instruction sequence that conforms to the design intention; An MCP service call driver for parsing and distributing instructions according to the generated MCP protocol instruction sequence, and gradually performing modeling by calling plugins to generate a preliminary building model or drawing, and auditing and optimizing the obtained preliminary building model or drawing, and finally completing automatic modeling based on the MCP protocol instruction.

[0178] Furthermore, the core components used by the MCP service call driver include: Component mcp-srv: An MCP protocol server that bridges the AI interaction platform and the Revit plugin, responsible for receiving instructions from the AI interaction platform and forwarding them to the Revit plugin through Socket; Component mcp-cmd: As a dynamic link library resource DLL with a "function instruction set", it is loaded and used by the plugin side mcp-addin; Component mcp-addin: As a Revit MCP plugin, an external application in Revit, responsible for loading the command set, establishing communication, and executing commands; The AI interaction platform converts the user's design requirements into a request that conforms to the MCP protocol according to a preset rule or algorithm, and sends the MCP request to mcp-srv; mcp-srv receives the MCP request from the AI interaction platform, parses the request content, determines the required plugins and functions to be called, and generates a corresponding Socket message and sends it to mcp-addin; mcp-addin receives the Socket message from mcp-srv, and according to the message content, triggers an ExternalEvent to call the instructions in the corresponding command set DLL; The instructions in the DLL perform specific modeling operations in the Revit application by calling the Revit API. After the modeling operation is completed, the Revit application feeds back the execution result to mcp-addin; The mcp - addin processes and encapsulates the execution results, generates a Socket response, and sends the Socket response to mcp - srv. The mcp - srv receives the Socket response from the plugin, parses and processes the content of the Socket response, generates a response that conforms to the MCP protocol, and sends it to the AI interaction platform.

[0179] It should be noted that for the detailed description of an architectural design automation modeling system combining LLM and MCP provided in the embodiments of the present invention, reference can be made to the relevant description of an architectural design automation modeling method combining LLM and MCP provided in the embodiments of the present invention, which will not be elaborated here.

[0180] In addition, the embodiments of the present invention also provide an electronic device, which includes: a processor and a memory; the memory is used to store one or more program instructions; the processor is used to run one or more program instructions to execute the steps of an architectural design automation modeling method combining LLM and MCP as described in any one of the above.

[0181] It should be noted that for the detailed description of an electronic device provided in the embodiments of the present invention, reference can be made to the relevant description of an architectural design automation modeling method combining LLM and MCP provided in the embodiments of the present invention, which will not be elaborated here.

[0182] In addition, the embodiments of the present invention also provide a computer - readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, it implements the steps of an architectural design automation modeling method combining LLM and MCP as described in any one of the above.

[0183] It should be noted that for the detailed description of a computer - readable storage medium provided in the embodiments of the present invention, reference can be made to the relevant description of an architectural design automation modeling method combining LLM and MCP provided in the embodiments of the present invention, which will not be elaborated here.

[0184] Those skilled in the art can understand that all or part of the functions of the various methods in the above embodiments can be implemented by hardware or by computer programs. When all or part of the functions in the above embodiments are implemented by computer programs, the programs can be stored in a computer-readable storage medium, which can include: read-only memory, random access memory, magnetic disks, optical disks, hard disks, etc. The above functions can be realized by a computer executing these programs. For example, the program is stored in the memory of the device, and when the processor executes the program in the memory, the above-mentioned all or part of the functions can be realized. In addition, when all or part of the functions in the above embodiments are implemented by computer programs, the programs can also be stored in storage media such as servers, other computers, magnetic disks, optical disks, flash drives or external hard drives, and saved to the memory of the local device by downloading or copying, or the system of the local device is updated. When the processor executes the program in the memory, all or part of the functions in the above embodiments can be realized.

[0185] The above uses specific examples to illustrate the present invention, which is only for helping to understand the present invention and is not intended to limit the present invention. For those skilled in the art of the present invention, according to the idea of the present invention, several simple deductions, deformations or substitutions can also be made.

Claims

1. An automated modeling method for architectural design that combines LLM and MCP, characterized in that, The method includes: Obtain the user's design requirements, retrieve various relevant knowledge in the pre-created local knowledge base according to the user's design requirements, create a prompt (Prompt) by combining the user's design requirements and the knowledge base retrieval results, and input the obtained prompt (Prompt) into the large language model to generate an MCP protocol instruction sequence that meets the design intent; Parse and distribute the instructions according to the generated MCP protocol instruction sequence, and perform modeling step by step by calling plugins to generate a preliminary building model or drawing, and review and optimize the obtained preliminary building model or drawing, and finally complete the automatic modeling based on the MCP protocol instructions.

2. The automated modeling method for building design combining LLM and MCP according to claim 1, wherein The creation of the local knowledge base specifically includes: Knowledge collection, knowledge indexing and vectorization, and knowledge update; The knowledge collection includes: Automatically start the process of extracting entries from design specification documents, historical project codes, or plugin documents according to scheduled tasks or external events; Perform OCR recognition on scanned documents or image-based documents, extract key fields and perform structured processing, and at the same time annotate metadata; Add labels to each extraction record for subsequent quick positioning and retrieval; The knowledge indexing and vectorization includes: Convert the text content into high-dimensional vectors and store them in the vector database to support fast semantic retrieval; Establish knowledge graph nodes and relationship edges according to the "component type - parameter - constraint" triple for structured query and rule reasoning; Combine the full-text retrieval and vector retrieval results, and use the Top-K aggregation and relevance ranking algorithms to improve the recall rate and accuracy; The knowledge update includes: Automatically identify new rules, abnormal cases, or optimization suggestions according to the feedback of the drawing review results; Import the extracted new entries into the knowledge base in a preset format and annotate the meta-information; Automatically trigger the incremental indexing process of the vector library and the knowledge graph after supplementation to ensure that new knowledge is immediately retrievable.

3. The architectural design automation modeling method combining LLM and MCP according to claim 1, characterized in that Obtain the user's design requirements, and retrieve various relevant knowledge in the pre-created local knowledge base according to the user's design requirements, specifically including: Extract keywords from the obtained user's design requirements and identify the design intent; Based on the obtained keywords and design intent, perform a search in the local knowledge base, quickly locate the knowledge entries containing the keywords according to the keywords, and perform a preliminary screening on the retrieval results in combination with the design intent, and preferentially select the design specifications, historical cases, or standard requirements that are closely related to the design requirements.

4. The architectural design automated modeling method combining LLM and MCP according to claim 3, wherein Create a prompt (Prompt) by combining the user's design requirements and the knowledge base retrieval results, specifically including: Organically combine the obtained keywords, design intent, and knowledge points in the knowledge base through template matching or statement generation logic to create an optimized prompt (Prompt), ensuring that the prompt (Prompt) can fully convey the design requirements and clearly guide the large language model to generate an MCP protocol instruction sequence in the direction that meets the design intent and relevant specification standards.

5. The architectural design automation modeling method combining LLM and MCP according to claim 1, characterized in that, Input the obtained prompt (Prompt) into the large language model to generate an MCP protocol instruction sequence that meets the design intent, specifically including: Use the large language model to generate an initial text description containing modeling operation steps; Perform grammar checking, semantic verification on the generated initial text, and adjust it according to the specification format of the MCP protocol instructions, finally generating an MCP protocol instruction sequence for describing the modeling operation steps to ensure the logic, integrity, and operability of the instruction sequence.

6. The architectural design automation modeling method combining LLM and MCP according to claim 1, characterized in that, Perform instruction parsing and distribution according to the generated MCP protocol instruction sequence, and perform modeling step by step by calling plugins to generate a preliminary building model or drawing, specifically including: After obtaining the MCP protocol instruction sequence, perform syntax and semantic parsing on the instructions, identify each operation step and related parameters in the instructions, and then distribute the instructions to the corresponding processing modules or plugin methods according to the type and content of the instructions; Based on the pre-created mapping table of instruction types and Revit-MCP plugin methods, look up the table according to the instruction type to find the corresponding Revit-MCP plugin method, ensuring that the correct Revit plugin function can be called to execute the instructions; According to the number and complexity of the instructions and the performance of Revit, divide the MCP protocol instruction sequence into multiple batches, and formulate the execution time and interval for each batch to avoid tool jamming caused by executing too many instructions simultaneously; According to the batched MCP protocol instruction sequence, push each instruction to the local MCP server through the JSON-RPC protocol in sequence, and transfer the instructions to the corresponding Revit plugin through the MCP server; The Revit plugin receives the JSON-RPC request from the MCP server and parses it to extract the command and related parameters of the instruction; According to the parsed command and parameters, perform corresponding modeling operations in the model space of Revit, including creating, modifying, or deleting components or primitives; After each instruction is executed by the Revit plugin, check whether the operation is successful. If successful, record the relevant information. If failed, capture and record the error information, and then send the execution result information back to the MCP server through the JSON-RPC protocol, and finally reach the MCP scheduling layer; After a series of instruction executions, generate a preliminary building model or drawing.

7. The automated modeling method for architectural design combining LLM and MCP according to claim 1, characterized in that Review and optimize the obtained preliminary building model or drawing, specifically including: Use the rule engine to perform compliance checking on the generated model or drawing according to the predefined design specifications and rules to verify whether it meets the design specifications; According to the preliminary building model or drawing and the compliance checking report, use the large language model to perform semantic review on the preliminary model and put forward optimization suggestions; Feed back the review results to the user and update the local knowledge base to improve the continuous learning ability of the system.

8. An architectural design automation modeling system that combines an LLM and an MCP, characterized in that, The system includes: An AI interaction platform for obtaining user design requirements, retrieving various relevant knowledge in the pre-created local knowledge base according to the user design requirements, creating a prompt Prompt by combining the user design requirements and the knowledge base retrieval results, and inputting the obtained prompt Prompt into the large language model to generate an MCP protocol instruction sequence that meets the design intent; The MCP service call driver is used to parse and distribute instructions according to the generated MCP protocol instruction sequence, and perform modeling step by step by calling plugins to generate a preliminary building model or drawing, and review and optimize the obtained preliminary building model or drawing, and finally complete the automatic modeling based on the MCP protocol instructions.

9. An electronic device, characterized in that, The device includes: a processor and a memory; The memory is used to store one or more program instructions; The processor is used to run one or more program instructions to execute the steps of an architectural design automation modeling method combining LLM and MCP according to any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, A computer program is stored on the computer-readable storage medium, and when the computer program is executed by the processor, the steps of an architectural design automation modeling method combining LLM and MCP according to any one of claims 1 to 7 are implemented.

Images