An intelligent deployment system and method based on a large language model

Abstract

This invention relates to the field of architecture deployment technology, specifically to an intelligent architecture deployment system and method based on a large language model. Specifically, it includes: an information interaction module storing a set of deployment strategy rules; a requirement parsing module parsing deployment intent primitives through preset mapping relationships to generate a structured target blueprint; a solution evaluation module dynamically calculating the adjudication weights of conflict identifiers based on the deployment strategy rule set to generate adjudication priorities, generating clarification queries and revising the structured target blueprint based on the adjudication priorities, and iteratively generating a comprehensive evaluation result; a deployment decision module combining multi-objective trade-offs with preset strategy axes to generate a candidate strategy matrix; quantifying risk adjustment utility scores and outputting an optimal execution parameter set through predictive reasoning on the candidate strategy matrix; and a solution generation module outputting an architecture deployment solution based on the optimal execution parameter set. This invention utilizes a large language model for intelligent reasoning, solution generation, and predictive decision-making, achieving autonomous decision-making and automated generation of architecture deployment.

Description

Technical Field

[0001] This invention relates to the field of architecture deployment technology, specifically to an intelligent architecture deployment system and method based on a large language model. Background Technology

[0002] In the deployment practice of enterprise software systems and cloud-native applications, designing a system architecture that can accurately meet business needs and balance multi-dimensional goals is a technical challenge. Traditional architecture deployment processes rely on manual methods for requirements analysis, solution design, and configuration writing. This process is not only lengthy but also prone to introducing errors and ambiguities in complex multi-party collaborations.

[0003] In existing technologies, although existing automation tools such as Infrastructure as Code (ICC) have improved the efficiency of deployment, their functionality focuses on executing a predefined architectural blueprint. Therefore, before this execution step, systematically converting high-level business requirements into a concrete architectural blueprint remains a crucial preliminary step in the deployment process. This step presents several technical challenges: First, the process of converting unstructured business requirements into structured technical parameters relies on human experience for interpretation and definition, leaving room for optimization in terms of efficiency and consistency. Second, architectural design requires balancing multiple interdependent objectives such as performance, cost, and security, making systematic optimization within a vast space of parameter combinations a challenge. Finally, comprehensively verifying the logical consistency and configuration rationality of the architectural solution before deployment to reduce later adjustment costs remains a key area of ​​ongoing research in this field.

[0004] In summary, existing technologies have shortcomings in achieving an end-to-end process from intelligent analysis of business requirements and multi-objective trade-off decisions to automated generation of architectural solutions. Therefore, this paper proposes an intelligent architecture deployment system and method based on a large language model. Summary of the Invention

[0005] The purpose of this invention is to provide an architecture intelligent deployment system and method based on a large language model for architecture deployment. To address the problems existing in the prior art, this invention specifically includes: an information interaction module for acquiring architecture deployment requirements and storing a preset architecture knowledge base and deployment strategy rule set; a requirement parsing module for identifying architecture deployment requirements, extracting deployment intent primitives, and generating a structured target blueprint by parsing the deployment intent primitives through preset mapping relationships and the architecture knowledge base; a solution evaluation module for evaluating the structured target blueprint and identifying conflict markers using an audit language model; dynamically calculating the adjudication weights of the conflict markers by calling the deployment strategy rule set, and generating adjudication priorities using the adjudication weights; generating clarification queries to obtain feedback information based on the adjudication priorities, correcting the structured target blueprint based on the feedback information, triggering a re-evaluation of the audit language model, and iteratively generating a comprehensive evaluation result; a deployment decision module for identifying the multi-objective trade-off points between the comprehensive evaluation result and the structured target blueprint using a strategy language model, generating a candidate strategy matrix by combining the multi-objective trade-off points with preset strategy axes; quantifying and generating risk-adjusted utility scores through predictive inference of the candidate strategy matrix, and outputting the optimal execution parameter set based on the risk-adjusted utility scores; and a solution generation module for outputting an architecture deployment solution based on the optimal execution parameter set. This invention utilizes intelligent reasoning, solution generation, and predictive decision-making based on large language models to achieve autonomous decision-making and automated generation of architecture deployment, thus solving the problem of low deployment efficiency caused by the inability to balance deployment costs, system response speed, and dynamic changes in business.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] An architecture-intelligent deployment system based on a large language model includes:

[0008] The information interaction module obtains architecture deployment requirements and stores a preset architecture knowledge base and deployment strategy rule set;

[0009] The requirements parsing module identifies architecture deployment requirements, extracts deployment intent primitives, and generates a structured target blueprint by parsing deployment intent primitives through preset mapping relationships and an architecture knowledge base.

[0010] The solution evaluation module uses an audit language model to evaluate the structured target blueprint and identify conflict markers; it calls the deployment strategy rule set to dynamically calculate the adjudication weight of the conflict markers and uses the adjudication weight to generate an adjudication priority; it generates clarification queries based on the adjudication priority to obtain feedback information, corrects the structured target blueprint based on the feedback information, triggers a re-evaluation of the audit language model, and iteratively generates a comprehensive evaluation result.

[0011] The deployment decision module uses a strategy language model to identify multi-objective trade-offs between the comprehensive evaluation results and the structured goal blueprint. It then combines these trade-offs with preset strategy axes to generate a candidate strategy matrix. Through predictive reasoning of the candidate strategy matrix, it quantifies and generates risk-adjusted utility scores. Based on these risk-adjusted utility scores, it outputs the optimal set of execution parameters.

[0012] The solution generation module outputs an architecture deployment solution based on the optimal set of execution parameters.

[0013] Preferably, the information interaction module includes: the architecture knowledge base containing best practice patterns, component templates, performance benchmarks, and constraint rules; and the deployment strategy rule set containing the predefined sorting rules for the adjudication priority.

[0014] Preferably, the requirement parsing module includes a natural language processing unit and a preset mapping database. The natural language processing unit uses natural language processing technology to identify and extract deployment intent primitives containing performance, cost, and security based on the architecture deployment requirements. The preset mapping database stores the mapping relationship between the deployment intent primitives and quantitative technical indicators, whereby the quantitative technical indicators include target response latency and budget ceiling. Based on the mapping relationship, the deployment intent primitives are converted into quantitative technical indicators. Based on the architecture knowledge base, constraint rules related to the quantitative technical indicators are retrieved, and a structured target blueprint containing constraint boundaries is constructed by combining the constraint rules and technical indicators.

[0015] Preferably, the solution evaluation module includes: dynamically constructing the architecture under test based on the structured target blueprint and the component template; calling the audit language model to compare and analyze the architecture under test with the performance benchmark and constraint rules, generating an initial comprehensive evaluation result containing potential risk points and conflict identifiers, whereby the conflict identifiers indicate logical conflicts between the architecture under test and the constraint rules; when the initial comprehensive evaluation result contains conflict identifiers, parsing the conflict identifiers to obtain the conflict domain and conflict type of the conflict identifiers, calling the deployment strategy rule set in combination with the conflict type, dynamically calculating the adjudication weight of the conflict identifiers, sorting the conflict identifiers based on the adjudication weights, and generating adjudication priorities; based on the adjudication priorities, constructing and issuing a clarification query containing recommended solutions, and obtaining feedback information; correcting the parameters of the structured target blueprint based on the feedback information; and re-triggering the audit language model for re-evaluation based on the corrected structured target blueprint, until a comprehensive evaluation result without conflict identifiers is generated.

[0016] Preferably, the deployment decision module includes: using a strategy language model to semantically associate and pattern match the comprehensive evaluation results with the structured target blueprint to locate multi-objective trade-off points; based on the multi-objective trade-off points, deconstructing the best practice pattern into infrastructure components; generating a baseline architecture scheme by adaptively fusing the infrastructure components; generating candidate architecture adjustment schemes by multi-dimensionally transforming the baseline architecture scheme based on a preset strategy axis; constructing a candidate strategy matrix based on the candidate architecture adjustment schemes; performing predictive reasoning on the candidate strategy matrix and generating a preliminary evaluation report; calculating the risk adjustment utility score of the candidate architecture adjustment schemes based on the preliminary evaluation report; ranking and deciding based on the risk adjustment utility score; and outputting the optimal execution parameter set.

[0017] Preferably, the scheme generation module includes: mapping the optimal execution parameter set to architecture configuration code using a preset generator plugin library; generating a deployment configuration file based on the architecture configuration code; generating natural language arguments based on end-to-end data; and outputting an architecture deployment scheme containing the deployment configuration file and the natural language arguments.

[0018] Preferably, the natural language argumentation includes: integrating end-to-end data containing architecture deployment requirements, structured target blueprints, comprehensive evaluation results, and optimal execution parameter sets; reasoning about the end-to-end data based on a preset explanation task prompt template, and generating a natural language argumentation containing a summary of potential risk points, explanations of multi-objective trade-offs, and reasons for adopting the optimal execution parameter set.

[0019] An architecture-intelligent deployment method based on a large language model includes:

[0020] Obtain architecture deployment requirements and store a pre-defined architecture knowledge base and deployment strategy rule set;

[0021] Identify deployment requirements and extract deployment intent primitives. Then, using pre-defined mapping relationships and an architecture knowledge base, parse the deployment intent primitives to generate a structured target blueprint.

[0022] The audit language model is used to evaluate the structured target blueprint and identify conflict markers; the deployment strategy rule set is invoked to dynamically calculate the adjudication weight of the conflict markers, and the adjudication weight is used to generate an adjudication priority; clarification queries are generated based on the adjudication priority to obtain feedback information, the structured target blueprint is corrected based on the feedback information, the audit language model is re-evaluated, and a comprehensive evaluation result is generated iteratively.

[0023] The strategy language model is used to identify the multi-objective trade-offs between the comprehensive evaluation results and the structured goal blueprint. The candidate strategy matrix is ​​generated by combining the multi-objective trade-offs with the preset strategy axes. The candidate strategy matrix is ​​then used to predictively infer the risk-adjusted utility score, and the optimal set of execution parameters is output based on the risk-adjusted utility score.

[0024] Deployment scheme based on the output architecture of the optimal execution parameter set.

[0025] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0026] 1. This invention identifies and extracts deployment intent primitives from requirements, converts them into quantitative technical indicators containing specific values ​​using pre-defined mapping relationships, and integrates relevant constraint rules retrieved from an architecture knowledge base. This constructs an automated conversion mechanism that precisely quantifies unstructured deployment intents into structured technical blueprints. Through this mechanism, the system systematically parses and constructs previously ambiguous business language into machine-readable structured target blueprints containing clear constraint boundaries and structured target blueprints. This method replaces the traditional process of interpreting and translating requirements based on human experience, avoiding overall design errors that may arise from subjective misunderstandings. It provides unambiguous single facts for subsequent automated evaluation and decision-making processes, ensuring the input quality and accuracy of the final results of the entire intelligent deployment system.

[0027] 2. This invention establishes a closed loop of human-machine collaborative risk diagnosis and solution correction by deeply integrating feedback information into the automated evaluation process. After identifying conflict markers using an audit language model, the system dynamically calculates the adjudication weights of conflicts by calling the deployment strategy rule set, and automatically constructs clarification queries containing recommended solutions based on the generated adjudication priorities. After receiving user feedback, the solution evaluation module can accurately revise the structured target blueprint and trigger iterative re-evaluation by the audit language model until no conflicts exist in the solution. This mechanism transforms the solution review process, which relies on human experience, into a standardized, traceable, and interactive audit process. By effectively converging risks in the early stages of decision-making, it ensures that the solution input in the final decision-making stage aligns with the user's true intentions, thereby improving the completeness and reliability of the decision-making basis.

[0028] 3. This invention, by deploying a decision-making module, constructs a closed-loop decision engine integrating derivative solution generation and predictive quantitative decision-making, achieving a complete process innovation from "option creation" to "optimal selection." The engine first combines multi-objective trade-offs with preset strategy axes to derivatively generate a candidate solution matrix rich in strategic diversity. It then performs in-depth predictive reasoning on each candidate solution in the matrix, generating multi-dimensional predictive evaluation reports and quantifying each candidate solution into a precise risk-adjusted utility score. This decision-making process, seamlessly integrating solution generation and quantitative evaluation, transforms qualitative comparisons relying on expert experience into a data-driven scientific decision-making paradigm. This broadens the scope and cutting-edge nature of decision options, enhances the objectivity, reproducibility, and high credibility of the final decision, and improves the flexibility and optimization potential of the architecture design. Attached Figure Description

[0029] Figure 1 This is a schematic diagram of the architecture of an intelligent deployment system based on a large language model according to the present invention;

[0030] Figure 2 This is a flowchart of the process for evaluating the solution of this invention.

[0031] Figure 3 This is a flowchart illustrating the deployment decision module of the present invention. Detailed Implementation

[0032] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0033] Please see Figures 1 to 3 This invention provides an intelligent deployment system and method based on a large language model, the technical solution of which is as follows:

[0034] An architecture-intelligent deployment system based on a large language model includes the following modules:

[0035] The information interaction module obtains architecture deployment requirements and stores a preset architecture knowledge base and deployment strategy rule set;

[0036] The requirements parsing module identifies architecture deployment requirements, extracts deployment intent primitives, and generates a structured target blueprint by parsing deployment intent primitives through preset mapping relationships and an architecture knowledge base.

[0037] The solution evaluation module uses an audit language model to evaluate the structured target blueprint and identify conflict markers; it calls the deployment strategy rule set to dynamically calculate the adjudication weight of the conflict markers and uses the adjudication weight to generate an adjudication priority; it generates clarification queries based on the adjudication priority to obtain feedback information, corrects the structured target blueprint based on the feedback information, triggers a re-evaluation of the audit language model, and iteratively generates a comprehensive evaluation result.

[0038] The deployment decision module uses a strategy language model to identify multi-objective trade-offs between the comprehensive evaluation results and the structured goal blueprint. It then combines these trade-offs with preset strategy axes to generate a candidate strategy matrix. Through predictive reasoning of the candidate strategy matrix, it quantifies and generates risk-adjusted utility scores. Based on these risk-adjusted utility scores, it outputs the optimal set of execution parameters.

[0039] The solution generation module outputs an architecture deployment solution based on the optimal set of execution parameters.

[0040] Example 1:

[0041] This embodiment provides a specific application of an architecture intelligent deployment system based on a large language model. Its typical application scenario is that e-commerce company A needs to quickly deploy backend service architecture for its online platform to cope with high concurrency traffic during promotional activities, and introduces an architecture intelligent deployment system based on a large language model.

[0042] See Figure 1 The system proposed in this invention specifically includes:

[0043] An architecture-intelligent deployment system based on a large language model includes:

[0044] The information interaction module obtains architecture deployment requirements and stores a preset architecture knowledge base and deployment strategy rule set;

[0045] The requirements parsing module identifies architecture deployment requirements, extracts deployment intent primitives, and generates a structured target blueprint by parsing deployment intent primitives through preset mapping relationships and an architecture knowledge base.

[0046] The solution evaluation module uses an audit language model to evaluate the structured target blueprint and identify conflict markers; it calls the deployment strategy rule set to dynamically calculate the adjudication weight of the conflict markers and uses the adjudication weight to generate an adjudication priority; it generates clarification queries based on the adjudication priority to obtain feedback information, corrects the structured target blueprint based on the feedback information, triggers a re-evaluation of the audit language model, and iteratively generates a comprehensive evaluation result.

[0047] The deployment decision module uses a strategy language model to identify multi-objective trade-offs between the comprehensive evaluation results and the structured goal blueprint. It then combines these trade-offs with preset strategy axes to generate a candidate strategy matrix. Through predictive reasoning of the candidate strategy matrix, it quantifies and generates risk-adjusted utility scores. Based on these risk-adjusted utility scores, it outputs the optimal set of execution parameters.

[0048] The solution generation module outputs an architecture deployment solution based on the optimal set of execution parameters.

[0049] Furthermore, the process of obtaining architecture deployment requirements, storing a preset architecture knowledge base and deployment strategy rule set, and corresponding to the system's information interaction module specifically includes:

[0050] E-commerce company A interacts with the system through an information interaction module, which integrates a hybrid input interface and an interaction processing unit. The hybrid input interface is configured to receive architecture deployment requirements input from the terminal. These requirements include unstructured requirements in natural language format and structured requirements with preset parameters. For example, unstructured requirement input: E-commerce company A can input a requirement description in natural language format through the text input box in the hybrid input interface. For example, company A inputs: "Design a backend service architecture for a new e-commerce platform, requiring it to handle sudden traffic surges, guarantee 99.95% availability, and keep the initial monthly cost below 3000 yuan." Structured requirement input: E-commerce company A can submit structured requirements defined with preset parameters through the form in the hybrid input interface. For example, the following parameters can be set: "Service type: E-commerce," "Availability index: 99.95%," "Monthly budget (yuan): ≤3000," "Target environment: AWS (Amazon Web Services)."

[0051] The interaction processing unit is configured to manage and coordinate the entire session flow, and the specific workflow is as follows:

[0052] Step S201: Receive initial requirements; The hybrid input interface receives the user's initial architecture deployment requirements and passes them to the requirement parsing module for preliminary parsing.

[0053] Step S202: Output a clarifying query; if the requirement parsing module identifies ambiguous or conflicting semantics in the requirement, such as the specific metrics for "burst traffic" being undefined, it will generate corresponding system interaction information. The interaction processing unit receives the system interaction information, formats it into a clarifying query, and outputs the clarifying query to the terminal through the interface. For example, output: Request received. To better quantify "burst traffic," please estimate the peak queries per second (QPS).

[0054] Step S203: Receive feedback; After seeing the clarification inquiry on the interface, e-commerce company A enters feedback information. For example, it enters "Peak QPS is expected to be 2000".

[0055] Step S204: Process continuous input. The interactive processing unit treats the feedback information as a continuous input and passes it to the requirement parsing module for the next round of processing.

[0056] The information interaction module stores a preset architecture knowledge base and deployment strategy rule set. The architecture knowledge base consists of a document database and a vector database, containing best practice patterns, component templates, constraint rules, and performance benchmarks. Component templates and constraint rules are defined in a structured format and stored in the document database; the component template is defined as a structured text object containing explicit fields, such as component identifier, cloud service provider, list of configurable parameters and their default values ​​and legal value ranges; the constraint rule is defined as a structured object containing rule ID, triggering conditions, and mandatory assertions. For example, a constraint rule could be "Rule ID-SEC01: For e-commerce architectures involving payment functions, their database components must enable static encryption." For the best practice pattern, during the system initialization phase, unstructured documents and semi-structured data in the knowledge base are fed into a vectorization processing engine. The engine uses a text embedding model to process the knowledge content into high-dimensional feature vectors and establishes an index relationship between these feature vectors and the original knowledge text. Finally, this index relationship is stored in a vector database. For example, the best practice pattern could be a scheme called "High Availability Elastic E-commerce Backend Pattern," which defines the core elements of a load balancer, application server autoscaling groups, and a cross-availability zone database. The performance benchmark stores performance data for different components under specific loads. For example, the component "Amazon EC2 t3. Medium" can stably handle approximately 800 QPS requests per instance under a specific application load.

[0057] The deployment strategy rule set defines the adjudication priority among different types of requirements. For example, it can be defined by an ordered priority list, where "security compliance" is set to have the highest priority, followed by "availability," "performance," and finally "cost." When the system detects a conflict between a user's low-cost preference and security compliance constraints, the system will enforce the security compliance rule according to this priority list.

[0058] Simultaneously, the information interaction module dynamically records the session history information generated by user input, including complete interaction sequences, terminal configuration preferences, and target environments. The complete interaction sequence records the question-and-answer dialogue between the user and the system; for example, the system outputs: "Please estimate peak QPS," and the terminal inputs: "Peak QPS is estimated to be 2000." By parsing the complete interaction sequence, the terminal configuration preferences are extracted. For example, if e-commerce company A selects "availability" in a clarifying question about "cost," it is recorded as "availability priority is greater than cost priority." The target environment is the deployment target platform determined from user needs, such as AWS (Amazon Web Services).

[0059] By pre-configuring an architectural knowledge base containing best practices and constraint rules, and defining clear decision priority rules, a professional and reliable data and logical foundation is provided for the system's automated evaluation and decision-making, ensuring the compliance of the output solutions and the consistency of decisions.

[0060] Furthermore, the identification architecture deployment requirements extract deployment intent primitives. Through preset mapping relationships and an architecture knowledge base, the deployment intent primitives are parsed to generate a structured target blueprint. The corresponding system requirement parsing module specifically includes:

[0061] After receiving the architecture deployment requirements and session history information, the requirement parsing module uses natural language processing technology to identify and extract deployment intent primitives from the architecture deployment requirement text. These deployment intent primitives include performance, availability, cost, and security.

[0062] The deployment intent primitives are transformed into quantifiable, structured target blueprints using a predefined mapping database. This database, configured based on expert experience, contains detailed structured information in its mapping rules. Specifically, this includes: a unique intent identifier; other intent types with trade-offs, such as "cost-sensitive"; specific quantitative technical indicators, such as "availability percentage" and "deployment mode"; each quantitative indicator includes its target value, acceptable range, and default value; and the mapping rules are linked to relevant mandatory constraint rules in the architecture knowledge base. For example, for the deployment intent primitive "high availability," its mapped structured object value includes "availability level not lower than 99.95%", "deployment mode is cross-availability zone", "disaster recovery strategy is off by default", and a "trade-off hint" field, where "trade-off hint" means "this item will increase cost." When the system identifies deployment intent primitives of "high availability" and "cost-sensitive", it merges the corresponding indicator lists of the deployment intent primitives into a unified preliminary set of technical indicators based on the priority determination preset in the deployment strategy rule set. The specific adjudication and merging logic is as follows: The system first retrieves the technical indicators corresponding to the intent primitives. For conflicting indicators, it queries the priority preset for the corresponding conflicting intent primitives in the deployment strategy rule set and automatically adopts the indicator value corresponding to the intent primitive with higher priority to form a unified preliminary set of technical indicators.

[0063] The system retrieves default metrics from the mapping database, combines these default metrics with session history information, and instantiates and overrides them to generate the final quantified target. During instantiation and override, the system follows a preset priority sequence, which can be set as follows: parameter values ​​explicitly specified by e-commerce company A in its structured requirements have the highest priority and will directly override all default metrics; terminal setting preferences parsed from session history have the second highest priority; if neither of these two explicit specifications is specified, the default values ​​in the mapping database are used. For example: in terms of performance, "peak QPS expected to be 2000" is converted to "throughput target: >= 2000 QPS"; in terms of availability, it is converted to "availability level: >= 99.95%, deployment mode: cross-availability zone"; in terms of cost, it is converted to "budget limit (RMB): <= 3000". The parsing unit, based on the structured target blueprint, retrieves relevant constraint rules from the architecture knowledge base of the information interaction module, for example, rule ID-SEC01, and combines the constraint rules with the structured target blueprint to finally construct and output a structured target blueprint containing complete constraint boundaries. By automatically converting vague natural language requirements into quantitative and structured target blueprints with clear constraints, the ambiguity and bias that may arise from human interpretation are eliminated at the source. This provides accurate and consistent input for subsequent automated processes, ensuring that the final solution accurately responds to user intent.

[0064] During the output of the structured target blueprint, a multi-source parameter consistency verification step is performed. This step specifically includes: extracting parameter values ​​for the same technical indicator based on architectural deployment requirements that include both unstructured and structured needs; comparing the extracted parameter values ​​to detect parameter conflicts; when a parameter conflict is identified, prioritizing the handling of the conflict based on preset data source clarity adjudication rules. These rules quantify clarity scores for parameter values ​​from different sources and adopt the parameter value with the highest score to resolve the conflict; when parameter values ​​have the same clarity score, a clarification query containing the conflicting parameter values ​​is generated for correction. By proactively cross-validating user input from different sources and quantifying clarity scores, the efficiency of requirement parsing is improved, and the reliability of the final output solution is enhanced.

[0065] Furthermore, the process of using an audit language model to evaluate the structured target blueprint and identify conflict markers; dynamically calculating the adjudication weights of the conflict markers by invoking the deployment strategy rule set; generating adjudication priorities using the adjudication weights; generating clarification queries based on the adjudication priorities to obtain feedback information; correcting the structured target blueprint based on the feedback information; triggering a re-evaluation of the audit language model; and iteratively generating a comprehensive evaluation result, corresponding to the system's solution evaluation module, specifically includes:

[0066] See Figure 2After receiving the structured target blueprint, the solution evaluation module initiates the process of generating initial test architecture information. This process specifically includes: extracting core feature tags from the structured target blueprint, such as service type: e-commerce, availability level: >99.9%; performing matching retrieval on the core feature tags based on the architecture knowledge base to locate the most relevant best practice pattern, such as a highly available elastic e-commerce backend pattern; the system traverses the component list defined by the best practice pattern, loading corresponding component templates for the core elements in the list. If a core element corresponds to multiple selectable component templates, the system will prioritize selecting the template that meets the core constraints and has the lowest estimated cost for instantiation and combination; the system initially assigns values ​​to the template parameters based on the specific values ​​in the structured target blueprint, such as budget limits and performance targets; if there is no direct correspondence, the system uses the default values ​​defined in the template; and combining the instantiated components into machine-readable test architecture information, which includes its topology and configuration.

[0067] The system generates an evaluation prompt containing information about the architecture under test, session history, and a structured target blueprint. This prompt is a structured request object containing dedicated fields for inputting contextual information, the architecture data to be evaluated, evaluation dimensions, and task instructions. The task instructions explicitly instruct the audit language model to perform specific tasks; for example, they could instruct the model to analyze the "architecture information under test" and, based on constraints and performance benchmarks in the "structured target blueprint," output all potential risk points and conflict indicators. The task instructions also require the audit language model to return results in a machine-readable structured text format, such as a text object containing "risk points," "conflict indicators," and "recommendations" fields. The system matches the parameters of the architecture under test with performance benchmarks and constraint rules in the knowledge base to generate comparison results. It then calls the audit language model to process the evaluation prompt and comparison results. Specifically, the audit language model utilizes a general-purpose large language model, guided by system prompts to act as an architecture audit expert, and outputs its analysis results in a structured text format containing conflict indicators, detailed descriptions, and severity levels.

[0068] Based on the processing of the audit language model, an initial comprehensive evaluation result containing conflict identifiers is generated. For example, the conflict identifier could be "Conflict Identifier-001: The estimated cost of the current architecture is detected to be 6000 yuan, exceeding the budget limit constraint of 3000 yuan." When a conflict identifier exists in the initial comprehensive evaluation result, its conflict domain and conflict type are obtained by parsing the conflict identifier. Subsequently, the solution evaluation module calls the deployment strategy rule set and, in conjunction with the conflict type, dynamically calculates the adjudication weight of the conflict identifier. The dynamic calculation process is as follows: First, the system assigns basic weight values ​​to the conflict domains according to the priority list preset in the deployment strategy rule set. For example, "security compliance" is set to 100 points, and "cost" is set to 70 points (weight range 0-100). Then, the system determines the adjustment coefficient by analyzing the terminal configuration preferences extracted from the session history information and applies an adjustment multiplier to the basic weights based on the terminal configuration preferences. For example, the conflict domain of "Conflict Identifier-001" is "cost" and e-commerce company A did not emphasize that cost is the highest priority in the conversation history information. Therefore, the decision weight of the conflict is dynamically calculated to be 70. If the user has stated in the interaction that "cost is the primary consideration", a preset adjustment multiplier of 1.2 times is applied to the basic weight.

[0069] In the process of dynamically calculating the adjudication weight of conflict identifiers, preliminary adjustment actions are generated based on component templates and constraint rules in the architecture knowledge base. Based on these preliminary adjustment actions and the architecture knowledge base, the dependencies of components related to the preliminary adjustment actions are traversed. The impact range of the preliminary adjustment actions on the architecture components is quantified based on these dependencies, generating a chain reaction index. This chain reaction index is then used as an independent adjustment factor and positively superimposed on the dynamic calculation of the adjudication weight to generate the final adjudication weight. By proactively assessing and quantifying the potential risks of the solution, risk-driven prioritization is achieved, improving collaborative efficiency and decision-making quality.

[0070] The conflict identifiers are sorted based on the adjudication weight to generate adjudication priorities. Based on these priorities, a clarifying query containing the recommended solution is generated, such as, "Analysis shows that the current solution exceeds the budget; according to the rules, high availability is the highest priority. It is recommended to adjust the computing instances to an auto-scaling group of 2 to 6 instances to optimize costs while maintaining availability." The module then asks whether to adopt this recommendation. Finally, upon receiving feedback indicating "adoption," the solution evaluation module updates the session history and modifies the structured target blueprint based on the feedback, triggering a new round of evaluation and ultimately generating a comprehensive evaluation result with no conflict identifiers. By establishing a closed-loop evaluation process, the static solution review is transformed into a dynamic collaborative optimization process, enabling in-depth risk diagnosis and dynamic correction of the architecture deployment, ensuring the rationality of the final solution.

[0071] Furthermore, the process involves using a strategy language model to identify multi-objective trade-offs between the comprehensive evaluation results and the structured goal blueprint, and combining these trade-offs with preset strategy axes to generate a candidate strategy matrix. Through predictive inference of the candidate strategy matrix, a risk-adjusted utility score is quantified, and based on this score, an optimal set of execution parameters is output, corresponding to the system's deployment decision module. This module specifically includes:

[0072] See Figure 3 The deployment decision module uses a strategy language model to semantically associate and pattern match the comprehensive evaluation results with the structured target blueprint, locating multi-objective trade-offs. For example, a multi-objective trade-off could be "how to configure auto-scaling groups to minimize monthly costs to no more than 3,000 yuan while meeting a peak performance of 2,000 QPS." Next, based on these multi-objective trade-offs, the system deconstructs relevant best practice patterns for infrastructure components. Through adaptive fusion of these infrastructure components, a customized baseline architecture scheme is generated. The deployment decision module combines preset strategy axes, such as "cost priority" and "performance priority," to perform multi-dimensional transformations on the baseline architecture scheme, ultimately generating candidate architecture adjustment schemes with different design focuses but all technically feasible. A candidate strategy matrix is ​​then constructed based on these candidate architecture adjustment schemes. For example: Scheme A (cost priority): minimum number of instances: 2, maximum number of instances: 6; Scheme B (performance priority): minimum number of instances: 3, maximum number of instances: 6.

[0073] In the process of generating the candidate policy matrix, an initial Pareto optimal solution set is constructed based on the initial candidate architecture adjustment schemes, and iterative optimization is performed. Iterative optimization includes: selecting schemes adjacent to the target dimension as parent schemes based on the current Pareto optimal solution set; generating child candidate architecture schemes by weighted averaging the execution parameters of the parent schemes; evaluating the child candidate architecture schemes using a policy language model and outputting evaluation data; performing Pareto optimality screening based on the evaluation data and updating the Pareto optimal solution set until convergence; using the converged Pareto optimal solution set as the final candidate architecture schemes, and constructing the candidate policy matrix based on the final candidate architecture schemes. By expanding the decision-making basis from a limited number of options to a Pareto optimal solution set closer to the true optimal boundary, the probability of finding a globally better solution is increased, thereby improving the system's decision quality and deployment efficiency.

[0074] Then, the system's built-in performance and cost assessment engine is invoked to perform predictive reasoning on the candidate architecture adjustment schemes. The predictive reasoning process specifically involves: estimating the response latency of the architecture under test under peak load using a preset linear interpolation method based on performance benchmark data; invoking the target cloud platform's real-time pricing API interface and accurately estimating cost metrics by combining the resource usage duration in the scheme; integrating the response latency cost metrics into a preliminary data report; and using a policy language model to integrate and interpret the preliminary data report, generating a preliminary assessment report containing performance, cost, and reliability dimensions. For example:

[0075] Solution A report: Estimated monthly cost of 2850 yuan, with a 99% response latency of 180ms under a peak load of 2000 QPS, which meets the requirements;

[0076] Option B report: Estimated monthly cost of 3400 yuan, with a 99% response latency of 120ms under a peak load of 2000 QPS, offering superior performance.

[0077] Finally, based on the user's cost constraint of "keeping costs within 3000 yuan," the system dynamically constructs a utility function and calculates the risk-adjusted utility score of the candidate solutions. For example, solution A, which fully meets all constraints, has a risk-adjusted utility score of 92; solution B, which exceeds the budget constraint, has a risk-adjusted utility score that drops to 0. The utility function is a multi-factor scoring model, specifically including: comparing and linearly normalizing the predicted values ​​of the candidate solutions with the cost, performance, and reliability dimensions in the structured target blueprint to generate a satisfaction score from 0 to 100; secondly, assigning importance weights to the evaluation dimensions based on the terminal configuration preferences reflected in the session history information; specifically, the system reuses the adjudication weight values ​​calculated for each conflict domain, normalizes them, and uses them as the importance weights for each evaluation dimension; and finally, the system weighted sums the satisfaction scores for each dimension to obtain the basic utility score. The multi-factor scoring model also includes a penalty mechanism. For candidate architecture adjustment schemes that violate hard constraints, their risk-adjusted utility score is directly determined as a preset penalty value, for example, the risk-adjusted utility score is set to zero. For compliant candidate architecture adjustment schemes, their base utility score is directly used as the risk-adjusted utility score. For example, if scheme B exceeds the budget limit of 3,000 yuan, the utility score of scheme B will be directly set to 0, while the fully compliant scheme A retains its higher original utility score of 92.

[0078] The system ranks and decides based on risk-adjusted utility scores, selecting the solution with the highest utility score and outputting the final optimal execution parameter set, for example: {"Compute Component": {"Type: AWS Autoscaling Group", "Instance Type: t3.Medium", "Minimum Number of Instances: 2", "Maximum Number of Instances: 6"}, "Database Component": {"Type: Cross-Availability Zone Database", "Instance Specification: t3.Medium", "Static Encryption: True"}}. By generating diverse candidate solutions in a derivational manner and combining predictive reasoning for quantitative risk assessment, the system transforms the "qualitative comparison" decision-making process into one that is both creative and scientific, increasing the probability of finding the global optimum and the credibility of the final result, while reducing reliance on human experience.

[0079] Furthermore, the step of generating a deployment configuration file adapted to the target environment based on the optimal set of execution parameters, corresponding to the system's solution generation module, specifically includes:

[0080] First, the optimal set of execution parameters output by the decision-making unit is received, and at the same time, the target environment information, such as Amazon Web Services (AWS), is obtained from the session history information stored in the information interaction module.

[0081] The solution generation module contains a generator plugin library, which pre-configures configuration file generators for various mainstream target environments, such as AWS, Microsoft Azure, and Google Cloud Platform. The plugins in this library adhere to a predefined interface specification, which requires each plugin to provide three core methods: the first method declares the name of the target environment supported by the plugin; the second is the core generation method, designed to receive a standardized set of optimal execution parameters output by the core engine as its sole input and return a complete, platform-specific configuration file in string format; the third is a validation method, used to check the syntax validity of the generated configuration file content and return the check results and possible error messages. Based on the obtained target environment information, the system automatically selects and loads a deployment configuration file generator plugin that conforms to the interface specification.

[0082] The deployment configuration file generator plugin reads the input optimal execution parameter set and executes a mapping process that includes dependency resolution. The mapping process is as follows: First, the plugin's mapping logic converts general system parameters into specific attributes in a specific configuration language according to preset rules; for example, converting "minimum number of instances" into "min_size". During this conversion, the system generates code blocks for the resources to be created, identifies dependencies between resources, and uses temporary placeholders; for example, the application server's dependency on the database address. Then, the plugin generates a resource dependency graph based on these dependencies. The specific generation process includes: First, the plugin traverses the optimal execution parameter set, generating graph nodes for the resources to be created, such as database instances and compute instances. Next, the plugin analyzes the dependencies between nodes. When it identifies that a downstream resource's attribute references the output of an upstream resource (e.g., a compute instance referencing the address of a database instance), a directed edge is established between the corresponding nodes of the two resources, pointing from upstream to downstream. Based on all directed edges representing dependencies, a resource dependency graph is generated. Finally, the system uses a topological sorting algorithm to traverse the resource dependency graph to ensure that resources without dependencies are written to the configuration first, and resources with dependencies are written later. During the writing process, the placeholders of resource references are replaced with the actual output values ​​generated by the upstream resources.

[0083] In this way, the plugin maps the optimal set of execution parameters to syntax code in a specific configuration language, such as HashiCorp Configuration Language (HCL). For example, the system's internal decision parameter "instance type" and its value are mapped to attributes in the target configuration language used to define specific instance specifications; the parameter "minimum number of instances" is mapped to attributes defining the scaling lower bound; and the boolean state of "static encryption" is mapped to the corresponding attribute for enabling or disabling storage encryption. Based on the converted configuration code, the final deployment configuration file is generated. Simultaneously, a syntax validity check is performed on the deployment configuration file, for example, by calling the validation tool associated with the configuration language to ensure that the configuration file is free of syntax errors and can be correctly parsed and executed by subsequent deployment tools. By mapping the optimal set of execution parameters to the configuration code of the target environment and utilizing a plugin library to achieve cross-platform adaptation, automated generation from intelligent decision-making to executable deployment files is achieved, improving the efficiency and flexibility of architecture deployment.

[0084] The system gathers end-to-end process data, including: architecture deployment requirements, structured target blueprints, comprehensive evaluation results, and optimal execution parameter sets. Based on a pre-defined explanation task prompt template, the gathered end-to-end process data is structurally integrated to generate comprehensive explanation prompts. The explanation task prompt template is a structured set of text instructions, specifically including fields for filling in data and step-by-step instructions. These step-by-step instructions may include the following steps: First, restate the user's core business objectives based on the content of the "Original User Requirement" field. Second, identify and summarize the key potential risk points discovered during the solution evaluation process based on the "Final Technical Blueprint" and "Optimal Execution Parameter Set." Third, explain the key trade-off decisions made to resolve these risks or conflicts. Fourth, clearly demonstrate why the "Adopted Execution Parameters" are the optimal choice under all constraints and trade-offs, and correlate them with the user's business objectives.

[0085] The comprehensive explanation prompts are processed by a large language model to generate structured natural language explanation text. For example, the natural language explanation text may include:

[0086] Requirements Restatement and Confirmation: We have received your request to deploy a backend service architecture for the e-commerce platform. The core objective is to achieve 99.95% availability and a peak performance of 2000 QPS on AWS, while strictly controlling the monthly cost to within 3000 yuan.

[0087] Summary of potential risks: The initial assessment revealed that while using large server instances with fixed specifications could meet performance requirements, the cost would exceed the budget and would not achieve the goal of elastic high availability.

[0088] Multi-objective trade-off explanation: To resolve the core conflict between availability and cost, the system has made key trade-offs and, after confirming with you, adopted the "elastic auto-scaling" solution. This solution maximizes cost-effectiveness while meeting the hard requirements for high availability.

[0089] The optimal execution parameter set was adopted because the final decision was to use a medium-sized t3 instance configured as an auto-scaling group of 2-6 nodes. This configuration can meet a peak performance of 2000 QPS while keeping daily operating costs low, scaling elastically only during peak traffic periods, thus keeping total costs within budget. By integrating end-to-end data and generating a comprehensive argument including risk summaries, trade-off explanations, and adoption rationale, the automated decision-making process was made transparent and traceable, improving the reliability of the final output solution.

[0090] This invention transforms complex and ambiguous architectural design requirements into specific and quantifiable automated processes by constructing a full-link intelligent process, thereby improving the efficiency of architecture deployment, reducing the reliance on human experience in complex architecture design, and enhancing the quality and reliability of the final deployment solution.

[0091] Example 2:

[0092] This embodiment applies an architecture-intelligent deployment system based on a large language model to another scenario: e-commerce company A already has a preliminary design plan and needs to introduce an architecture-intelligent deployment system to verify and optimize the design plan.

[0093] First, e-commerce company A uploads a structured requirement file defined with preset parameters as its architecture deployment requirements through the mixed input interface of the information interaction module. This structured requirement file defines a solution using three fixed c5.large computing instances and one rds.m5.large instance. Simultaneously, e-commerce company A adds a natural language requirement: "Verify the feasibility of this solution within a budget of 3000 yuan, achieving 2000 QPS and 99.95% availability." After receiving the mixed structured and unstructured requirements, the requirement parsing module parses the natural language requirements and converts them into quantitative technical indicators. These quantitative technical indicators are then combined with the architecture deployment requirements to construct a structured target blueprint.

[0094] After receiving the architecture information and structured target blueprint, the solution evaluation module performs a compliance audit. The system calls the architecture knowledge base to obtain corresponding performance benchmarks and best practice patterns. The audit language model compares and analyzes the preliminary design solution with the performance benchmarks and best practice patterns. For example, the cost of a c5.large instance is approximately 1800 yuan per month, and the "high-availability elastic e-commerce backend model" requires elastic scaling. An initial comprehensive evaluation result containing conflict indicators is generated, such as: Conflict Identifier-201: The estimated cost of the solution exceeds the budget limit constraint of 3000 yuan; Conflict Identifier-202: The solution using a fixed number of instances does not conform to the "high-availability elastic e-commerce backend model," and is expected to have more than 70% resource waste during non-promotional periods, failing to meet cost-effectiveness best practices. Subsequently, the solution evaluation module dynamically calculates the adjudication weight of the conflict indicators. For example, the system may calculate the weight of "Conflict Identifier-201" as 90 and the weight of "Conflict Identifier-202" as 75. Based on the adjudication weights, the system generates an adjudication priority that prioritizes cost issues and constructs a clarification query accordingly, recommending an optimization solution based on "auto-scaling groups" to e-commerce company A. By intelligently comparing and analyzing the preliminary design proposals submitted by users with the best practices in the knowledge base, the system proactively identifies potential cost and performance risks in the proposals, thereby improving the cost-effectiveness and technical rationality of the architectural solutions.

[0095] The system outputs a clarifying query containing the conflict identifier to e-commerce company A and recommends an optimization scheme based on "auto-scaling groups". After e-commerce company A confirms through interactive means, the deployment decision module initiates the decision-making process:

[0096] First, the module identifies "optimizing cost while meeting performance and availability requirements" as the core multi-objective trade-off. Next, it generates a candidate strategy matrix containing various scaling configurations based on preset strategy axes. Then, the decision-making unit performs predictive inference on the candidate solutions in the matrix, deriving their estimated costs and response latency under different traffic volumes, and finally calculating their respective risk-adjusted utility scores. The system selects the solution with the highest utility score as the optimal execution parameter set and passes it to the solution generation module. Finally, it outputs an optimized deployment configuration file and a natural language explanation, which includes a comparison of the advantages and disadvantages of the preliminary design solution and the optimized solution.

[0097] Example 3:

[0098] This embodiment applies an architecture-based intelligent deployment system based on a large language model to e-commerce company A as described in Embodiment 1. In order to reduce operating costs, e-commerce company A inputs a new request, the content of which is to disable the static encryption function at the database level in order to minimize costs.

[0099] The requirement parsing module parses the request to determine the terminal configuration preference that prioritizes cost over security. During the evaluation process, the solution evaluation module retrieves relevant constraint rules from the architecture knowledge base: "Rule ID-SEC01: For any e-commerce architecture involving payment functions, its database components must enable static encryption."

[0100] E-commerce company A's request to disable static encryption conflicted with rule ID-SEC01. The solution evaluation module generated a conflict identifier in the initial comprehensive evaluation result: "Conflict Identifier-301: The requested static encryption function conflicts with rule ID-SEC01." Upon identifying the conflict identifier, the solution evaluation module immediately initiated the adjudication process: first, it analyzed the conflict domain and conflict type; for example, the conflict domain could be "security," and the conflict type could be "violation of hard constraint rules." Then, it invoked the deployment policy rule set to dynamically calculate the conflict identifier adjudication weight. Since this conflict belonged to the "hard conflict" domain under "security compliance," its adjudication weight was calculated as the highest priority value; the adjudication priority generated based on this weight was determined to be the highest level. Based on the adjudication priority, the system interrupted the regular optimization and decision-making process. By identifying hard conflicts with core constraints and immediately invoking preset rules for adjudication, the system achieved rapid interruption and processing of invalid or dangerous user requests, improving the system's decision robustness.

[0101] The solution generation module was invoked to generate a natural language explanation based on this mandatory ruling. Finally, the system output a response message rejecting the request to e-commerce company A through the information interaction module: "Request rejected; your requested operation has a hard conflict with security compliance (rule ID-SEC01). The system dynamically calculates and determines that the priority of this conflict ruling is the highest level, non-negotiable. To ensure payment security, the static encryption function of the database is an unchangeable hard constraint." By generating a rejection response message referencing the specific ruling rule, a clear explanation of the mandatory decision was achieved, ensuring that users could understand the compliance reasons behind it and enhancing the system's transparency.

[0102] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. An architecture-based intelligent deployment system based on a large language model, characterized in that, include: The information interaction module obtains architecture deployment requirements and stores a preset architecture knowledge base and deployment strategy rule set; The requirements parsing module identifies architecture deployment requirements, extracts deployment intent primitives, and generates a structured target blueprint by parsing deployment intent primitives through preset mapping relationships and an architecture knowledge base. The requirement parsing module includes a natural language processing unit and a preset mapping database; the natural language processing unit uses natural language processing technology to identify deployment requirements based on the architecture and extract deployment intent primitives containing performance, cost, and security considerations. A pre-defined mapping database stores the mapping relationship between the deployment intent primitives and quantitative technical indicators. The quantitative technical indicators include target response latency and budget ceiling. Based on the mapping relationship, the deployment intent primitives are converted into quantitative technical indicators. Based on the architecture knowledge base, constraint rules related to the quantitative technical indicators are retrieved. The constraint rules and technical indicators are combined to construct a structured target blueprint containing constraint boundaries. The solution evaluation module uses an audit language model to evaluate the structured target blueprint and identify conflict markers. The system dynamically calculates the adjudication weight of the conflict identifier by calling the deployment strategy rule set, and generates an adjudication priority using the adjudication weight; it generates a clarification inquiry based on the adjudication priority to obtain feedback information, corrects the structured target blueprint based on the feedback information, triggers a re-evaluation of the audit language model, and iteratively generates a comprehensive evaluation result. The deployment decision module uses a strategy language model to identify the multi-objective trade-offs between the comprehensive evaluation results and the structured goal blueprint, and combines the multi-objective trade-offs with the preset strategy axes to generate a candidate strategy matrix. The candidate strategy matrix is ​​predicted and reasoned to generate a risk-adjusted utility score. Based on the risk-adjusted utility score, the optimal set of execution parameters is output. The solution generation module outputs an architecture deployment solution based on the optimal set of execution parameters.

2. The intelligent deployment system based on a large language model according to claim 1, characterized in that, The information interaction module includes: the architecture knowledge base contains best practice patterns, component templates, performance benchmarks, and constraint rules; the deployment strategy rule set contains the predefined sorting rules for the adjudication priority.

3. The intelligent deployment system based on a large language model according to claim 2, characterized in that, The solution evaluation module includes: dynamically constructing the architecture under test based on the structured target blueprint and the component template; calling the audit language model to compare and analyze the architecture under test with the performance benchmark and constraint rules, generating an initial comprehensive evaluation result containing potential risk points and conflict identifiers, whereby the conflict identifiers indicate logical conflicts between the architecture under test and the constraint rules; when conflict identifiers exist in the initial comprehensive evaluation result, parsing the conflict identifiers to obtain their conflict domains and conflict types, calling the deployment strategy rule set in conjunction with the conflict types, dynamically calculating the adjudication weight of the conflict identifiers, sorting the conflict identifiers based on the adjudication weights, and generating adjudication priorities; based on the adjudication priorities, constructing and issuing a clarification query containing recommended solutions, and obtaining feedback information; correcting the parameters of the structured target blueprint based on the feedback information; and re-triggering the audit language model for re-evaluation based on the corrected structured target blueprint, until a comprehensive evaluation result without conflict identifiers is generated.

4. The intelligent deployment system based on a large language model according to claim 3, characterized in that, The deployment decision module includes: using a strategy language model to semantically associate and pattern match the comprehensive evaluation results with the structured target blueprint to locate multi-objective trade-off points; based on the multi-objective trade-off points, deconstructing the best practice pattern into infrastructure components; generating a baseline architecture scheme by adaptively fusing the infrastructure components; generating candidate architecture adjustment schemes by multi-dimensionally transforming the baseline architecture scheme based on a preset strategy axis; constructing a candidate strategy matrix based on the candidate architecture adjustment schemes; performing predictive reasoning on the candidate strategy matrix and generating a preliminary evaluation report; calculating the risk adjustment utility score of the candidate architecture adjustment schemes based on the preliminary evaluation report; ranking and deciding based on the risk adjustment utility score; and outputting the optimal execution parameter set.

5. The intelligent deployment system based on a large language model according to claim 1, characterized in that, The scheme generation module includes: mapping the optimal execution parameter set to architecture configuration code using a preset generator plugin library; generating a deployment configuration file based on the architecture configuration code; generating natural language arguments based on end-to-end data; and outputting an architecture deployment scheme containing the deployment configuration file and the natural language arguments.

6. The intelligent deployment system based on a large language model according to claim 5, characterized in that, The natural language argumentation includes: integrating end-to-end data containing architecture deployment requirements, structured target blueprints, comprehensive evaluation results, and optimal execution parameter sets; reasoning about the end-to-end data based on a preset explanation task prompt template, and generating a natural language argumentation that includes a summary of potential risk points, explanations of multi-objective trade-offs, and reasons for adopting the optimal execution parameter set.

7. An intelligent deployment method for architecture based on a large language model, characterized in that, include: Obtain architecture deployment requirements and store a pre-defined architecture knowledge base and deployment strategy rule set; The system identifies deployment requirements and extracts deployment intent primitives. Through a preset mapping relationship and architecture knowledge base, it parses the deployment intent primitives to generate a structured target blueprint. The requirement parsing module includes a natural language processing unit and a preset mapping database. The natural language processing unit uses natural language processing technology to identify and extract deployment intent primitives containing performance, cost, and security based on the architecture deployment requirements. A pre-defined mapping database stores the mapping relationship between the deployment intent primitives and quantitative technical indicators. The quantitative technical indicators include target response latency and budget ceiling. Based on the mapping relationship, the deployment intent primitives are converted into quantitative technical indicators. Based on the architecture knowledge base, constraint rules related to the quantitative technical indicators are retrieved. The constraint rules and technical indicators are combined to construct a structured target blueprint containing constraint boundaries. The audit language model is used to evaluate the structured target blueprint and identify conflict markers; the deployment strategy rule set is invoked to dynamically calculate the adjudication weight of the conflict markers, and the adjudication weight is used to generate an adjudication priority; clarification queries are generated based on the adjudication priority to obtain feedback information, the structured target blueprint is corrected based on the feedback information, the audit language model is re-evaluated, and a comprehensive evaluation result is generated iteratively. The strategy language model is used to identify the multi-objective trade-offs between the comprehensive evaluation results and the structured goal blueprint, and the candidate strategy matrix is ​​generated by combining the multi-objective trade-offs with the preset strategy axes. The candidate strategy matrix is ​​predicted and reasoned to generate a risk-adjusted utility score. Based on the risk-adjusted utility score, the optimal set of execution parameters is output. Deployment scheme based on the output architecture of the optimal execution parameter set.

Images