Multi-agent system for generating trestle design model under driving of large model

Abstract

The invention discloses a multi-agent system for generating a trestle design model under the drive of a large model, and relates to the technical field of BIM and AI crossing. The working process of the system comprises the steps that after a user inputs an instruction, the system automatically verifies parameters such as span combination and bridge floor total length, and the number of steel pipe piles is deduced through bridge pier rank calculation; the architect agent adopts a hierarchical layout algorithm and completes component coordinate derivation in combination with a default table; a programmer agent generates modeling codes according to a priority rule, and the problems of parameter missing, family library mismatching and the like are solved through an error self-correction strategy. The system integrates a long-term / short-term memory mechanism, realizes design parameter tracing and modeling process closed-loop optimization, and remarkably improves the design efficiency and modeling automation level of a complex trestle structure.

Description

Technical Field

[0001] The present invention belongs to the field of the intersection of BIM and AI technology, and specifically relates to a multi-agent system that drives a large model to generate a trestle design model. Background Art

[0002] In the field of modern construction engineering, the design and construction of piers and bridges have placed higher demands on accuracy, efficiency and intelligence. Traditional design methods rely on designers to manually calculate parameters, draw drawings and make repeated adjustments, which have problems such as low efficiency, easy errors and difficulty in adapting to complex working conditions. Although Building Information Modeling (BIM) technology has been widely used in three-dimensional modeling, its degree of automation is limited. Especially when dealing with complex structures such as piers, users still need to have professional knowledge to complete tasks such as parameter input, component layout and conflict detection. In addition, traditional design tools lack the ability to intelligently parse natural language instructions, resulting in a large gap between the design process and user needs.

[0003] The shortcomings of existing technologies include:

[0004] Insufficient parameter verification and conflict detection: Trestle design involves key parameters such as span, deck length, and Bailey length. Traditional methods require manual verification of the logical relationship between parameters. If the parameters conflict or are invalid, they must be manually adjusted or re-entered, which is time-consuming and prone to missing potential problems.

[0005] Layout planning relies on experience: The layout of trestle components must adhere to strict structural rules. Traditional design relies on the designer's judgment, making rapid iteration and adaptive optimization difficult. For example, the coordinate calculation of the main longitudinal beam requires considering the geometric center and elevation changes of the steel pipe piles. Manual derivation is prone to errors.

[0006] The modeling process is inefficient and relies on specialized skills: While BIM tools like Revit can generate 3D models, their workflow is cumbersome, requiring component calls to be executed manually one by one, and they lack the ability to directly respond to natural language commands. Designers must be proficient in the Revit API and programming logic to achieve automated modeling of complex structures, which is a high barrier to entry.

[0007] Insufficient error correction and fault tolerance: When encountering problems such as missing parameters, missing library components, or position conflicts, traditional design tools usually only prompt errors and cannot automatically correct them. Repeated user intervention is required, affecting design continuity.

[0008] In recent years, artificial intelligence (AI), particularly agent-based systems based on large language models (LLMs), has demonstrated significant potential in the construction industry. Multi-agent technology, through distributed collaboration, can simulate the decision-making processes of human experts, automating parameter verification, layout planning, and modeling tasks. Examples include LLM agents, BIM and AI integration, and memory optimization. This system, through the deep integration of LLM agents and a Revit plug-in, automates the entire process from natural language input to 3D model generation. This significantly improves the efficiency, accuracy, and intelligence of trestle design, providing an innovative solution for rapid design and iteration in complex engineering scenarios. Summary of the Invention

[0009] In order to overcome the shortcomings and deficiencies of the above-mentioned prior art, the present invention adopts the following technical solutions:

[0010] A multi-agent system for generating trestle design models driven by a large model, including an LLM agent module and a Revit plug-in module;

[0011] LLM agent module: including tool library, requirements analyst agent, architect agent and programmer agent;

[0012] Tool Library: Contains a set of modeling functions encapsulated based on the Revit API, covering the generation logic of 14 types of components, including piers, braces, diagonal braces, main longitudinal beams, baileys, support frames, bridge decks, guardrail crossbars, and guardrail posts, for creating trestle and bridge structure components;

[0013] Demand Analyst Agent: This agent verifies the design parameters in the text instructions provided by the user. Verification parameters include span, deck length, and Bailey length. It identifies conflicts and automatically adjusts them. If a conflict is found that cannot be automatically adjusted, the agent will provide feedback and ask the user to re-enter the instructions.

[0014] Architect Agent: used for layout planning and parameter filling engine;

[0015] Programmer Agent: used for module code generation and execution controller;

[0016] Revit plug-in module: including UI interaction interface, code execution engine and component reader;

[0017] UI interaction interface: supports natural language command input and 3D preview;

[0018] Code execution engine: communicates with the agent through RESTful API;

[0019] Component Reader: Synchronize Revit family library metadata in real time;

[0020] Among them, the intelligent agent has long-term and short-term memory functions. The long-term memory module is used to store important information of components, including component ID, location, and size; the short-term memory module stores information about tool execution errors. The intelligent agent will combine the information of long-term memory and short-term memory to select the next action to be performed.

[0021] Preferably, the system workflow is as follows:

[0022] S1: The demand analyst agent parses natural language instructions and executes the span verification algorithm, calculates the total length of the bridge deck, and detects parameter conflicts in the derivation of the number of steel pipe piles.

[0023] S2: The architect agent generates the trestle layout based on rule-based reasoning and parameter filling, determines component position dependencies and repetitive structure layout rules, and automatically uses default values ​​or adaptive calculation methods to determine parameters that are not explicitly specified.

[0024] S3: The programmer agent calls the tool library functions according to the layout and generates modeling code according to the priority control logic;

[0025] S4: The code execution engine injects code and implements error self-correction strategies.

[0026] Preferably, the span modular adjustment algorithm is specifically as follows:

[0027] When the span is single span, calculate whether the span is divisible by the length of the Bailey plate. If the span is not divisible by the length of the Bailey plate, adjust it to The rounding direction is downward;

[0028] When the span is a combined span of [A×B+C], execute the following for A and B respectively:

[0029]

[0030] Non-standard values ​​of the head and tail span C are allowed, but the minimum structural force value of C ≥ 1.5m must be met, otherwise an error will be reported.

[0031] Preferably, the adaptive layout planning includes:

[0032] The position of each component is determined by the spatial coordinates of the object it supports. If a repeated structure is involved, it is generated based on the standard of "two piles placed above and below each pile." Finally, regular expressions are used to automatically derive the component's structured description, including name, coordinates, and direction. For parameters that are not explicitly specified, default values ​​or adaptive calculation methods are automatically used to determine the parameters.

[0033] Also includes the following:

[0034] Calculation of the number of main longitudinal beams: Quantity = total number of steel pipe piles ÷ 2;

[0035] Determine the coordinates of the main longitudinal beam: obtain the maximum elevation h of the top of the steel pipe pile max and the minimum elevation of the top of the steel pipe pile h min , calculate the median shift The Z-axis coordinate of the main longitudinal beam is the pile top elevation + Δh, with millimeter-level accuracy. The axis of the main longitudinal beam is parallel to the centerline of the bridge deck, with an allowable angular deviation of less than or equal to 0.5°.

[0036] Repeating structure generation rules: Steel tie beams are generated according to the principle of "two beams above and below each pile", and channel steels are arranged in horizontal / vertical categories.

[0037] Preferably, the priority control table includes:

[0038] The sequence of substructure generation is: steel pipe piles → main longitudinal beams → transverse steel tie beams → longitudinal steel tie beams → channel steels;

[0039] The sequence of superstructure generation is: Bailey plate → support frame → bridge deck → guardrail column → guardrail crossbar;

[0040] Execution constraint principles: integrity check > quantity matching > function mapping > generation order > format specification.

[0041] Preferably, the memory module comprises:

[0042] Long-term memory: stores JSON structured data of component ID, spatial coordinates, and size parameters;

[0043] Short-term memory pool: records the error logs of the last 20 API calls, including error type, timestamp, and repair action;

[0044] Error self-correction strategies include: retrieving the most recent valid value when a parameter is missing, switching to a similar type when the family is not found, and retrying with a 50mm offset when there is a position conflict.

[0045] Preferably, every 5 minutes the component reader of the Revit plugin module executes:

[0046] Call FilteredElementCollector.OfClass(FamilySymbol) to scan the current document;

[0047] Extract family name, type name, and parameter list and update them to tool library function dictionary;

[0048] Metadata consistency is ensured by CRC32 checksum.

[0049] Preferably, the total length of the bridge deck is calculated as: When the user-specified total length conflicts with the calculated value, it is forcibly overwritten with 1.05 times the user-specified value. The calculation rule for the number of steel pipe piles is as follows: the number of rows of steel pipe piles arranged horizontally along the bridge deck is fixed at 2 rows, and the number of columns = the total number of spans + 1.

[0050] Preferably, modeling code generation includes:

[0051] Unit conversion: Convert the millimeter value entered by the user to the foot unit required by Revit API. The conversion formula is: feet = millimeter value ÷ 304.8;

[0052] Transaction control: ensure the atomicity of modeling operations through Transaction.Start() / Commit();

[0053] Exception Catching: Use a try-except block to catch the FamilySymbolNotFoundException and trigger memory retrieval.

[0054] In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are:

[0055] 1. The demand analyst agent in this invention uses a pre-defined span verification algorithm, total bridge deck length calculation rules, and steel pipe pile quantity derivation logic to automatically detect conflicts and intelligently correct user-entered parameters. For parameters not explicitly specified, the system automatically fills in default values ​​or adaptive algorithms, reducing user input costs while ensuring the engineering feasibility of design parameters through the rule engine.

[0056] 2. This invention uses the Programmer Agent, based on the structured layout design generated by the Architect Agent, to automatically generate and execute modeling code using a pre-set process control table and priority determination principles (completeness first, quantity first, etc.). Furthermore, the code output adheres to a strict format (one call per line with a numbered suffix), avoiding redundant symbols. The generated model file is highly readable and traceable.

[0057] 3. The present invention constructs a closed-loop feedback mechanism through long- and short-term memory modules: long-term memory stores key information such as component ID, position, and size, providing historical valid value retrieval for parameter missing scenarios; short-term memory captures tool execution errors (such as family not found, position conflict) in real time and triggers automatic correction strategies. This self-correction capability makes the system more adaptable in complex engineering environments and significantly reduces manual debugging costs. It is especially suitable for bridge design scenarios with multiple versions of iterations, ensuring the continuity of the modeling process and model accuracy. BRIEF DESCRIPTION OF THE DRAWINGS

[0058] 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.

[0059] Figure 1 A module diagram of a multi-agent system for generating a trestle design model driven by a large model according to the present invention is shown;

[0060] Figure 2 Shown is a workflow diagram of the present invention;

[0061] Figure 3 Shown is a flow chart of the execution of the memory module of the present invention. DETAILED DESCRIPTION

[0062] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0063] In addition, the described features, structures or characteristics can be combined in any suitable manner in one or more example embodiments. In the following description, many specific details are provided to provide a full understanding of the example embodiments of the present disclosure. However, those skilled in the art will appreciate that the technical solutions of the present disclosure can be practiced while omitting one or more of the specific details, or other methods, components, steps, etc. can be adopted. In other cases, well-known structures, methods, implementations or operations are not shown or described in detail to avoid obscuring various aspects of the present disclosure.

[0064] Example 1:

[0065] See Figure 1 As shown, a multi-agent system for generating a trestle design model driven by a large model in this embodiment includes an LLM agent module and a Revit plug-in module.

[0066] LLM agent module: includes tool library, requirements analyst agent, architect agent and programmer agent.

[0067] Tool Library: Contains a set of modeling functions encapsulated based on the Revit API, covering 14 types of component generation logic, including piers (steel pipe piles), tie beams (steel tie beams), diagonal braces (channel steels), main longitudinal beams, Bailey plates, support frames, bridge decks, guardrail crossbars, and guardrail columns, used to create pier and bridge structure components.

[0068] The Requirements Analyst Agent verifies the design parameters in the text instructions provided by the user. Parameters verified include span, deck length, and bailey length. Conflicts between these parameters are detected and automatically adjusted. If a conflict is found that cannot be automatically adjusted (e.g., an invalid instruction with a negative span), the agent prompts the user to re-enter the instruction.

[0069] Architect Agent: Engine for layout planning and parameter filling.

[0070] Programmer agent: reads the trestle layout design of the architect agent, plans the modeling task based on the currently available components, and calls the tool library to execute the modeling task.

[0071] Revit plug-in module: includes UI interaction interface, code execution engine and component reader.

[0072] UI interaction interface: supports natural language command input and 3D preview.

[0073] Code execution engine: communicates with the agent through RESTful API.

[0074] Component Reader: Synchronize Revit family library metadata in real time.

[0075] See Figure 2 As shown, in this embodiment, a large model drives a multi-agent system to generate a trestle design model. The workflow is as follows:

[0076] Step 1: User command parsing and parameter verification.

[0077] Extract natural language commands entered by users in the Revit plug-in interface (e.g., "generate a steel trestle with a span of 6×9m");

[0078] The Demand Analyst Agent performs parameter conflict detection: span verification algorithm; total bridge deck length calculation; and steel pipe pile quantity derivation.

[0079] The process of checking parameter conflicts is as follows:

[0080] 1) Verification of steel pipe pile span:

[0081] If the span is provided directly: calculate whether the span is divisible by the Bailey length. If not, adjust it to The rounding direction is downward.

[0082] If a span (or combination of spans) is provided, but the spans are of the form [A×B+C]: this means that the first and last spans are of span C, with an intermediate span of span A and span B. Calculate whether spans B and C are both divisible by the Bailey length. If not, then

[0083] Non-standard values ​​of the head and tail spans C are allowed (to adapt to boundary conditions), but they must meet the minimum structural force (such as C ≥ 1.5m), otherwise an error will be reported.

[0084] 2) Calculation of total bridge deck length:

[0085] The sum of the spans of each span is the total length of the bridge deck (the spans of the first span and the last span are not necessarily equal). At this time, even if the user clearly indicates the total length of the bridge deck in the instruction, it will be overwritten.

[0086] 3) The calculation rule for the number of steel pipe piles is: the number of rows of steel pipe piles arranged horizontally along the bridge deck is fixed at 2 rows, and the number of columns = the total number of spans + 1.

[0087] Step 2: Adaptive layout planning.

[0088] Based on verified user instructions, the architect agent generates a trestle or bridge layout design through a structural hierarchical layout algorithm based on rule reasoning and parameter filling. Using an automatic reasoning mechanism, it first determines the position of each component based on the spatial coordinates of its supporting object (such as steel pipe piles, main longitudinal beams, etc.); if repeated structures are involved (such as steel tie beams and channel steels), it will be generated based on the standard of "two piles placed above and below each pile"; finally, regular expressions are used to automatically deduce structured descriptions such as component name, coordinates, and direction.

[0089] For parameters that are not explicitly specified, the default values ​​or adaptive calculation methods are automatically used to determine the parameters. The default values ​​of the specified parameters are as follows:

[0090]

[0091] Taking the main longitudinal beam layout as an example, the adaptive layout calculation formula is: Quantity = Total number of steel pipe piles ÷ 2; Each main longitudinal beam is erected in the middle position of the two columns of steel pipe piles corresponding to the first row; The main longitudinal beam coordinates are derived as follows: Get the median offset h max h is the maximum elevation of the top of the steel pipe pile; min It is the minimum elevation of the top of the steel pipe pile; the center point of the main longitudinal beam is located at the geometric center of the two rows of steel pipe piles, the Z-axis coordinate = pile top elevation + Δh, and the accuracy is controlled to the millimeter level; the axis of the main longitudinal beam is parallel to the center line of the bridge deck, and the allowable angular deviation is ≤0.5°.

[0092] The trestle or bridge layout is designed according to the rules set out below:

[0093] 1) Overall structure: including the width and length of the trestle or bridge.

[0094] 2) Substructure:

[0095] Piers: Calculate row and column spacing based on span (or span combination) and bridge deck length and width, and you can set the size.

[0096] Main longitudinal beam: Centrally installed on a pair of piers, the size can be set.

[0097] Diagonal bracing / parallel bracing: generated between the steel pipe piles at the head and tail of the trestle.

[0098] 3)Superstructure:

[0099] Baileys: Installed on the main longitudinal beams, the number is calculated based on the length and width of the bridge deck. If the length and width are not divisible, they are rounded up. The spacing between each row of Baileys can be set.

[0100] Support frame: installed between Bailey pieces.

[0101] 4) Bridge deck attachment:

[0102] Bridge deck: Erected on Bailey plates, the quantity is calculated based on the overall size of the bridge deck and the size of the bridge deck. If it cannot be divided evenly, it will be rounded up. The size can be set.

[0103] Guardrail crossbar: located on both sides of the bridge deck, two on each side, the length of the crossbar is the same as the total length of the bridge deck.

[0104] Guardrail posts: located at the connection of the bridge deck on both sides of the bridge deck.

[0105] Step 3: Modeling code generation and execution.

[0106] The programmer agent reads the trestle layout design of the architect agent, plans the modeling task based on the currently available components, and calls the tool library to execute the modeling task.

[0107] The flow control table for the programmer agent calling a function is as follows:

[0108]

[0109]

[0110] The corresponding priority determination principles are as follows:

[0111] Completeness first: Any parameter must be explicitly filled in even if it is the default value. Failure to fill it in is considered an error.

[0112] Quantity priority: Strictly follow the quantity / combination given in the design plan, no increase or decrease is allowed.

[0113] Function mapping priority: First search for the most directly corresponding function in the tool library. If it does not exist, try the general function. Otherwise, an error will be reported.

[0114] Position / order priority: Generate sequentially in layout order (row → column → level) to maintain readability and traceability.

[0115] Format constraints take precedence: the final output must not contain redundant symbols (such as ````), and must be called one line at a time with a "|number" suffix.

[0116] The agent has long-term and short-term memory functions. The long-term memory module is used to store important information about components, such as component ID, location, and size. The following is an example of data in the long-term memory: {'code':200,'family_instance_id':351808,'message':'Main longitudinal beam-2HN500×200mm successfully created','family':'Steel pipe pile 1-Ф630×10mm','location_point':(36000,4500,250),'parameters':{'length':21000}}

[0117] The short-term memory module stores information about tool execution errors, and the agent will combine the information from long-term and short-term memory to select the next action to be performed. The execution process of the memory module is as follows: Figure 3 shown.

[0118] Step 4: Modeling execution and feedback.

[0119] S41. The code execution engine dynamically injects code through the Revit API.

[0120] Use the Transaction mechanism to ensure the atomicity of operations;

[0121] Exceptions are caught in real time and written to short-term memory.

[0122] S42. Error self-correction strategy.

[0123] Parameter missing: retrieve the most recent valid value from long-term memory.

[0124] Family not found: automatically switches to a similar family type (such as Ф630×10mm→Ф600×12mm).

[0125] Position conflict: Retry insertion with a 50mm offset.

[0126] The beneficial effects of this embodiment are as follows: the system realizes automatic parameter verification and dynamic adjustment through intelligent agent collaboration, and supports natural language interaction and real-time 3D preview in combination with the Revit plug-in, which significantly improves the efficiency of trestle design and parameter accuracy, reduces human errors, optimizes the multi-component modeling process, and enables non-professional users to efficiently generate professional-level bridge models.

[0127] The above description is only a preferred specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any technician familiar with the technical field, within the technical scope disclosed by the present invention, who makes equivalent replacements or changes based on the technical solution and inventive concept of the present invention, should be covered by the scope of protection of the present invention.

[0128] The preferred embodiments of the present invention disclosed above are intended only to help illustrate the present invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the present invention to specific embodiments. Obviously, many modifications and variations are possible based on the contents of this specification. These embodiments are selected and described in detail in this specification to better explain the principles and practical applications of the present invention, thereby enabling those skilled in the art to better understand and utilize the present invention. The present invention is limited only by the claims and their full scope and equivalents.

Claims

1. A multi-agent system for generating a trestle design model driven by a large model, characterized in that: The system includes an LLM intelligent body module and a Revit plug-in module; LLM agent module: including tool library, requirements analyst agent, architect agent and programmer agent; Demand Analyst Agent: This agent verifies the design parameters in the text instructions provided by the user, including span, deck length, and Bailey length. It also verifies conflicts between parameters and automatically adjusts them. If a conflict is found that cannot be automatically adjusted, the agent will provide feedback and ask the user to re-enter the instructions. Architect Agent: used for layout planning and parameter filling engine; Programmer Agent: used for module code generation and execution controller; Revit plug-in module: including UI interaction interface, code execution engine and component reader; Among them, the intelligent agent has long-term and short-term memory functions. The long-term memory module is used to store important information of components, including component ID, location, and size; the short-term memory module stores information about tool execution errors. The intelligent agent will combine the information of long-term memory and short-term memory to select the next action to be performed.

2. The multi-agent system for generating a trestle design model driven by a large model according to claim 1 is characterized in that: The system workflow is as follows: S1: The demand analyst agent parses natural language instructions and executes the span verification algorithm, calculates the total length of the bridge deck, and detects parameter conflicts in the derivation of the number of steel pipe piles. S2: The architect agent generates the trestle layout based on rule-based reasoning and parameter filling, determines component position dependencies and repetitive structure layout rules, and automatically uses default values ​​or adaptive calculation methods to determine parameters that are not explicitly specified. S3: The programmer agent calls the tool library functions according to the layout and generates modeling code according to the priority control logic; S4: The code execution engine injects code and implements error self-correction strategies.

3. The multi-agent system for generating a trestle design model driven by a large model according to claim 2 is characterized in that: The span modular adjustment algorithm is specifically as follows: When the span is single span, calculate whether the span is divisible by the length of the Bailey plate. If the span is not divisible by the length of the Bailey plate, adjust it to The rounding direction is downward; When the span is a combined span of [A×B+C], execute the following for A and B respectively: Non-standard values ​​of the head and tail span C are allowed, but C ≥ 1.5m must be met, otherwise an error will be reported.

4. The multi-agent system for generating a trestle design model driven by a large model according to claim 2 is characterized in that: The adaptive layout planning includes: The position of each component is determined by the spatial coordinates of its supporting object. If a repetitive structure is involved, it is generated based on the standard of "two piles placed above and below each pile." Finally, regular expressions are used to automatically derive the component's structured description, including name, coordinates, and direction. For parameters that are not explicitly specified, default values ​​or adaptive calculation methods are automatically used to determine the parameters. Also includes the following: Calculation of the number of main longitudinal beams: Quantity = total number of steel pipe piles ÷ 2; Determine the coordinates of the main longitudinal beam: obtain the maximum elevation h of the top of the steel pipe pile max and the minimum elevation of the top of the steel pipe pile h min , calculate the median shift The Z-axis coordinate of the main longitudinal beam is the pile top elevation + Δh, with millimeter-level accuracy. The axis of the main longitudinal beam is parallel to the centerline of the bridge deck, with an allowable angular deviation of less than or equal to 0.5°. Repeating structure generation rules: Steel tie beams are generated based on "two above and below each pile", and channel steels are arranged in a horizontal / vertical manner.

5. The multi-agent system for generating a trestle design model driven by a large model according to claim 2 is characterized in that: The priority control table includes: The sequence of substructure generation is: steel pipe piles → main longitudinal beams → transverse steel tie beams → longitudinal steel tie beams → channel steels; The sequence of superstructure generation is: Bailey plate → support frame → bridge deck → guardrail column → guardrail crossbar; Execution constraint principles: integrity check > quantity matching > function mapping > generation order > format specification.

6. The multi-agent system for generating a trestle design model driven by a large model according to claim 1 is characterized in that: The memory module comprises: Long-term memory: stores JSON structured data of component ID, spatial coordinates, and size parameters; Short-term memory pool: records the error logs of the last 20 API calls, including error type, timestamp, and repair action; Error self-correction strategies include: retrieving the most recent valid value when a parameter is missing, switching to a similar type when the family is not found, and retrying with a 50mm offset when there is a position conflict.

7. The multi-agent system for generating a trestle design model driven by a large model according to claim 2 is characterized in that: The component reader of the Revit plugin module executes every 5 minutes: Call FilteredElementCollector.OfClass(FamilySymbol) to scan the current document; Extract family name, type name, and parameter list and update them to tool library function dictionary; Metadata consistency is ensured by CRC32 checksum.

8. The multi-agent system for generating a trestle design model driven by a large model according to claim 2 is characterized in that: The total length of the bridge deck is calculated as: i is the span index number, counting from 1; n is the total number of spans. When the user-specified total length conflicts with the calculated value, it is forcibly overwritten with 1.05 times the user-specified value. The calculation rule for the number of steel pipe piles is as follows: the number of rows of steel pipe piles arranged horizontally along the bridge deck is fixed at 2 rows, and the number of columns = the total number of spans + 1.

9. The multi-agent system for generating a trestle design model driven by a large model according to claim 2 is characterized in that: The modeling code generation includes: Unit conversion: Convert the millimeter value entered by the user to the foot unit required by Revit API. The conversion formula is: feet = millimeter value ÷ 304.8; Transaction control: ensure the atomicity of modeling operations through Transaction.Start() / Commit(); Exception Catching: Use a try-except block to catch the FamilySymbolNotFoundException and trigger memory retrieval.

Images