Cloud management task execution method and apparatus, storage medium, device, and program

Abstract

The application discloses a cloud management task execution method and device, a storage medium, equipment and a program, relates to the field of cloud computing, and comprises the following steps: matching a received text corresponding to a user instruction with a first dictionary to determine a processing object that is allowed to process the user instruction, wherein the first dictionary is associated with a business field of the cloud management task; in the case that the processing object comprises a large language model and a risk decision for a first intention of the user instruction is a first value, constructing a prompt word of the large language model according to the text and a preset vector database to obtain an ordered task list output by the large language model corresponding to the user instruction; and executing the cloud management task in the ordered task list. Through the application, the problem that the cloud management mode in the prior art mainly relies on a graphical user interface and a command line interface to realize management, operation is complex and inefficient is solved, and the cloud management efficiency is improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of cloud computing, and in particular, to a cloud management task execution method and device, a storage medium, equipment and a program. BACKGROUND

[0002] With the deep popularization of cloud computing technology, private cloud has become the core of the information technology (IT) infrastructure of many large and medium-sized enterprises. The private cloud environment carries the key business of the enterprise, and its scale and complexity are growing, covering thousands of resource instances such as computing, storage, network, and security. Traditional cloud management methods mainly rely on graphical user interface (GUI) and command-line interface (CLI). Although GUI is intuitive, it often requires users to click multiple times between complex menus and forms when dealing with batch, repetitive or complex operation and maintenance tasks, which is inefficient. Although CLI is powerful and supports automated scripts, it requires operators to remember a large number of precise commands and parameters, and the learning curve is steep, which is extremely unfriendly to non-professionals.

[0003] Therefore, in the related art, there is a problem that cloud management methods mainly rely on graphical user interface (GUI) and command-line interface (CLI) to implement management, which is complex and inefficient to operate.

[0004] Therefore, the problem that cloud management methods mainly rely on graphical user interface (GUI) and command-line interface (CLI) to implement management, which is complex and inefficient to operate, in the related art, has not been effectively solved. SUMMARY

[0005] The present application provides a cloud management task execution method and device, a storage medium, equipment and a program to at least solve the problem that cloud management methods mainly rely on graphical user interface (GUI) and command-line interface (CLI) to implement management, which is complex and inefficient to operate in the related art.

[0006] The application provides a cloud management task execution method, comprising: matching a received text corresponding to a user instruction with a first dictionary to determine a processing object that allows processing of the user instruction, wherein the first dictionary has an association relationship with a business field of a cloud management task; in a case where it is determined that the processing object includes a large language model and a risk decision of a first intention of the user instruction is a first value, constructing a prompt word of the large language model according to the text and a preset vector database to obtain an ordered task list output by the large language model corresponding to the user instruction, wherein the first value is used to indicate that the first intention passes risk detection; and executing a cloud management task in the ordered task list.

[0007] The application also provides a cloud management task execution device, comprising: a matching module configured to match a received text corresponding to a user instruction with a first dictionary to determine a processing object that allows processing of the user instruction, wherein the first dictionary has an association relationship with a business field of a cloud management task; a obtaining module configured to, in a case where it is determined that the processing object includes a large language model and a risk decision of a first intention of the user instruction is a first value, construct a prompt word of the large language model according to the text and a preset vector database to obtain an ordered task list output by the large language model corresponding to the user instruction, wherein the first value is used to indicate that the first intention passes risk detection; and an execution module configured to execute a cloud management task in the ordered task list.

[0008] The application also provides an electronic device, comprising: a memory configured to store a computer program; and a processor configured to execute the computer program to implement steps of any of the cloud management task execution methods.

[0009] The application also provides a computer readable storage medium, wherein the computer readable storage medium stores a computer program, and the computer program is executed by a processor to implement steps of any of the cloud management task execution methods.

[0010] The application also provides a computer program product, comprising a computer program, and the computer program is executed by a processor to implement steps of any of the cloud management task execution methods.

[0011] By the present application, the received user instruction corresponding text is matched with the first dictionary to determine the processing object allowed to process the user instruction, wherein the first dictionary has an association relationship with the business field of cloud management task; in the case of determining that the processing object includes a large language model and the risk decision of the first intention of the user instruction is a first value, the prompt word of the large language model is constructed according to the text and the preset vector database to obtain the ordered task list output by the large language model corresponding to the user instruction, wherein the first value is used to indicate that the first intention passes the risk detection; the cloud management task in the ordered task list is executed. By the present application, the problem that the cloud management mode in the related art mainly depends on the graphical user interface and the command line interface to realize management, the operation is complex and the efficiency is low is solved, and the cloud management efficiency is improved. BRIEF DESCRIPTION OF DRAWINGS

[0012] In order to more clearly illustrate the embodiments of the present application, the drawings needed in the embodiments will be briefly introduced. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can be obtained by those skilled in the art without creative labor.

[0013] Figure 1 is a hardware structure block diagram of a computer terminal of a cloud management task execution method according to an embodiment of the present application;

[0014] Figure 2 is a flow chart of a cloud management task execution method according to an embodiment of the present application;

[0015] Figure 3 is an architecture diagram of a cloud management task execution system according to an optional embodiment of the present application;

[0016] Figure 4 is a framework diagram of a cloud management task execution device according to an embodiment of the present application. DETAILED DESCRIPTION

[0017] The technical solutions in the embodiments of the present application will be described clearly and completely in combination with the drawings in the embodiments of the present application. Obviously, the described embodiments are only some of the embodiments of the present application, not all. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor are within the protection scope of the present application.

[0018] It should be noted that, in the description of this application, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. The terms "first," "second," etc., in this application are used to distinguish similar objects and are not used to describe a specific order or sequence.

[0019] To enable those skilled in the art to better understand the present application, the present application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0020] The specific application environment architecture or specific hardware architecture on which the execution method of cloud management tasks depends is described here.

[0021] The methods and embodiments provided in this application can be executed on server devices, mobile terminals, computer terminals, or similar computing devices. Taking running on a computer terminal as an example, Figure 1 This is a hardware structure block diagram of a computer terminal for executing a cloud management task according to an embodiment of this application. Figure 1 As shown, a computer terminal may include one or more ( Figure 1 Only one is shown in the diagram. A processor 102 (which may include, but is not limited to, a central processing unit (CPU), microprocessor unit (MPU), or programmable logic device (PLD)) and a memory 104 for storing data are also shown. The computer terminal may further include a transmission device 106 for communication functions and an input / output device 108. Those skilled in the art will understand that... Figure 1 The structure shown is for illustrative purposes only and does not limit the structure of the computer terminal described above. For example, the computer terminal may also include components that are more complex than those described above. Figure 1 The more or fewer components shown, or having the same Figure 1 The different configurations shown.

[0022] The memory 104 can be used to store computer programs, such as application software programs and modules, like the computer program corresponding to the method for determining the interaction state in this embodiment. The processor 102 executes various functional applications and data processing by running the computer program stored in the memory 104, thus implementing the above-described method. The memory 104 may include high-speed random access memory and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 104 may further include memory remotely located relative to the processor 102, and these remote memories can be connected to a computer terminal via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0023] The transmission device 106 is used to receive or send data via a network. Specific examples of the network described above may include a wireless network provided by a communication provider for the computer terminal. In one example, the transmission device 106 includes a Network Interface Controller (NIC), which can connect to other network devices via a base station to communicate with the Internet. In another example, the transmission device 106 may be a Radio Frequency (RF) module used for wireless communication with the Internet.

[0024] Figure 2 This is a flowchart of a cloud management task execution method according to an embodiment of this application, which can be applied to... Figure 1 In computer terminals, such as Figure 2 As shown, the process includes the following steps:

[0025] Step S202: Match the text corresponding to the received user instruction with the first dictionary to determine the processing object that is allowed to process the user instruction, wherein the first dictionary is related to the business domain of cloud management tasks;

[0026] The first dictionary is a keyword dictionary, and the processing objects that can process user commands include: question-answering components with question-answering whitelists, business processing agents, and large language models.

[0027] Step S204: When it is determined that the processing object includes a large language model and the risk decision for the first intent of the user instruction is a first value, the prompt words of the large language model are constructed according to the text and a preset vector database to obtain an ordered task list corresponding to the user instruction output by the large language model, wherein the first value is used to indicate that the first intent passes the risk detection.

[0028] Optionally, the first value can be "Pass".

[0029] Step S206: Execute the cloud management task in the ordered task list.

[0030] Through the above steps, the text corresponding to the received user instruction is matched with a first dictionary to determine the processing object allowed to process the user instruction. The first dictionary is associated with the business domain of the cloud management task. If the processing object is determined to include a large language model, and the risk decision for the first intent of the user instruction is a first value, prompt words for the large language model are constructed based on the text and a preset vector database to obtain an ordered task list corresponding to the user instruction output by the large language model. The first value indicates that the first intent passes risk detection. The cloud management task in the ordered task list is then executed. This application solves the problem that cloud management methods in related technologies mainly rely on graphical user interfaces and command-line interfaces for management, resulting in complex operations and low efficiency, thus improving cloud management efficiency.

[0031] In one exemplary embodiment, the text corresponding to the received user instruction is matched with a first dictionary to determine the processing object that is allowed to process the user instruction. This includes: if the text matches a question on the question-answering whitelist in the question-answering component using a first regular expression, the processing object allowed to process the user instruction includes the question-answering component; if the user instruction is not a complex instruction and the text matches a target keyword in the first dictionary, the processing object allowed to process the user instruction includes a business processing agent; if the user instruction is a complex instruction or the text does not match a target keyword in the first dictionary, the processing object allowed to process the user instruction includes a large language model.

[0032] In other words, the first regular expression is used to match whether there are questions in the text that are similar to those in the question-and-answer whitelist. If similar questions are found, the processing object is determined to include the question-and-answer component. While determining whether the processing object includes the question-and-answer component, it is also possible to determine whether the user instruction is a complex instruction and whether the text hits the target keywords in the first dictionary, thereby determining whether the processing object includes the business processing agent or the large language model (also known as the large language model).

[0033] The determination of complex instructions includes: whether a complex instruction can be directly attributed to a single intent + parameter without requiring additional information; text can be judged as complex if it meets any of the following conditions 1) to 4):

[0034] 1) Multiple Actions: Two or more executable verbs / subtasks appear (e.g., "create...and mount...and add..."). For employees with multiple actions, "multiple" usually starts with two actions (because they already need to be programmed / decomposed); three or more actions are even more significant.

[0035] 2) Strong constraints / multiple combinations of conditions: The same sentence contains multiple specifications / filtering conditions / dependencies (Central Processing Unit (CPU) / memory / network / environment / quantity / time, etc.).

[0036] 3) There are ambiguous terms that cannot be directly parameterized: such as "higher / larger / as soon as possible / suitable / cheaper / good performance / stable", which cannot be mapped to specific parameters or require default strategies.

[0037] Fuzzy terms, also known as fuzzy descriptions, are usually relative quantities, subjective adjectives, or dimensionless expressions (high, low, large, fast, slow, cheap, etc.). Unless the system has a clear mapping table of "adjective → parameter level", they should be considered fuzzy.

[0038] 4) Unclear reference / missing key slots: such as "Give me a test machine" (missing specifications, network, image, etc.).

[0039] It should be noted that the implementation of this application does not limit the order of complex instruction determination and execution between matching business processing agents. First, keywords can be used to identify a specific domain and the business processing agent within that domain. Then, within that domain, a judgment can be made regarding "simple direct access vs. deep identification / decomposition / clarification" (i.e., whether it carries an instruction). This approach can quickly route instructions to the correct domain while avoiding the direct execution of complex instructions as simple instructions.

[0040] In an exemplary embodiment, matching the text corresponding to a received user instruction with a first dictionary to determine the processing object that is allowed to process the user instruction includes: matching the text with the first dictionary using a multi-pattern matching algorithm to determine the target keyword that the text matches in the first dictionary, wherein the first dictionary is used to record the target keyword and also to indicate the correspondence between the target keyword and the business domain of the cloud management task; making decisions on multiple business domains corresponding to the target keyword according to preset routing rules, wherein the preset routing rules are used to indicate the routing priority of each of the multiple business domains; and determining the target agent indicated by the decision result as the processing object, wherein the target agent is the business processing agent corresponding to the business domain with the highest routing priority among the multiple business domains, and each of the multiple business domains corresponds to a different business processing agent.

[0041] Understandably, the first dictionary is a dictionary containing keywords from different business domains, including: intelligent reporting, monitoring and alerting, and cloud resource management. The corresponding business processing agents for each business domain include: intelligent reporting agent, monitoring and alerting agent, and cloud resource management agent. For example, if the text matches "costs" in the intelligent reporting domain and "virtual machine" in the cloud resource management domain, and the preset routing rules indicate that the route priority for intelligent reporting is higher than that for cloud resource management, then the user command and text are directly sent to the intelligent reporting agent under the intelligent reporting domain for processing. The business processing agent is used to quickly execute received user commands, such as generating reports or performing monitoring operations.

[0042] Through the embodiments of this application, by employing a multi-pattern matching algorithm and preset routing rules, the system can quickly identify keywords in user instructions and efficiently assign instructions to the most suitable business processing agent based on the business domain association and priority of the keywords. This achieves rapid routing and classification of private cloud management tasks, significantly improving processing efficiency and user experience.

[0043] In an exemplary embodiment, before constructing prompt words for the large language model based on the text and a preset vector database to obtain an ordered task list corresponding to the user instruction output by the large language model, the method further includes: identifying a first word in the text used to describe changes in the lifecycle of cloud resources through a preset vocabulary, wherein the preset vocabulary includes verbs and phrases used to describe changes in the lifecycle of cloud resources; matching the first word with a second word corresponding to a cloud resource entity included in the text to determine the first intent; and performing a risk assessment on the first intent through a rule engine to determine a risk decision for the first intent.

[0044] The first vocabulary is a high-risk intent vocabulary. The verbs and phrases in the first vocabulary that describe changes in the resource lifecycle include the following categories: creation, such as "create" and "new"; change, such as "power on", "power off", and "restart"; and deletion, such as "delete", "destroy", and "release".

[0045] Further, matching the first word with the second word corresponding to the cloud resource entity included in the text to determine the first intent includes: determining the dependency relationship between the first word and the second word in the text, and the context rules corresponding to the first word and the second word in the text, wherein the context rules are used to indicate the association relationship between modifiers and a third word in the text, the third word including: the first word and the second word; matching the first word and the second word through the dependency relationship and the context rules to obtain the first intent.

[0046] Specifically, dependency relationships and context rules refer to: not only checking whether the target keyword is hit in the text (target keywords include the first word and the second word), but also checking the grammatical relationship / relative position / negation and scope of the target keyword in the text, and using a set of executable rules to determine "what object (including cloud resource entities) the verb acts on", thereby outputting the first intent.

[0047] Among them, dependency relations refer to using lightweight syntax or dependency analysis to determine the relationship between action verbs (i.e., the first word) and object entities (i.e., the second word) (such as verb-object relations (VOB), preposition-object relations (POB), attributive relations (ATT)). For example, ensuring that "delete" actually applies to "virtual machine / hard drive / network" and not to other contexts.

[0048] Among them, context rules (position / modification): refers to the relationship between modifiers and third words in the text. You can choose to use windows and trigger words to handle modifiers such as negation, scope, environment, quantity (e.g., "don't / don't", "batch / all", "production / test", "check only / don't execute") to avoid misjudging as write operations or high-risk intentions.

[0049] Matching the first word and the second word through the dependency relationship and the context rules includes: if it is determined that there is a dependency relationship between the first word and the second word, and if it is determined through the context rules that it is neither a write operation nor a high-risk intent, then the first word and the second word can be concatenated according to the concatenation rules to obtain the first intent.

[0050] The splicing rules include:

[0051] (Verb [reboot class]) + (Object [virtual machine entity]) yields the first intent intent_reboot_vm.

[0052] (Verb [Expansion type]) + (Object [Hard disk entity]) + (Value [Capacity]) then yields the first intent intent_resize_disk.

[0053] (verb [create class]) + (object [virtual machine entity]) + (specification (cpu / memory (Memory, abbreviated as mem))) then we get the first intent intent_create_vm.

[0054] If a negative word ([do not / don't]) appears and is matched (delete / restart, etc.), it will be marked as "negative / consult only" and will not be executed.

[0055] If the phrase "(scope term [all / batch]) + (resource entity)" appears, the batch is marked as high-risk and the process proceeds to the strategy reasoning / approval path.

[0056] Furthermore, a risk assessment is performed on the first intent using a rule engine to determine a risk decision regarding the first intent. This includes: obtaining target information of the user who initiated the user instruction, wherein the target information includes: user identity, user historical behavior, user permissions, and the first intent; and matching the target information with predefined security policies within the rule engine to determine a risk decision regarding the first intent.

[0057] User permissions are the permissions of the Identity and Access Management (IAM) system.

[0058] Through the embodiments of this application, by conducting pre-process lifecycle intent recognition and security policy assessment, the system can accurately determine the changes to cloud resource entities involved in user instructions, and perform risk analysis in conjunction with the user's specific information and predefined security rules. This allows the system to make decisions on whether to allow the call or require further approval before calling a large language model, effectively improving the operational security and efficiency in a private cloud environment, while reducing the expensive model call costs.

[0059] In an exemplary embodiment, constructing prompt words for the large language model based on the text and a preset vector database includes: performing a similarity search on the vector database using query information corresponding to the text to obtain search results, wherein the vector database includes: first vector data and second vector data, wherein the first vector data is vector data corresponding to historical dialogues between the user and the large language model, and the second vector data is vector data corresponding to component information of all components of cloud resources; wherein the query information includes: a second intent of the text determined by a hierarchical intent classification model and / or keywords of the text generated by a preset generation model; and constructing the prompt words using the search results and the text.

[0060] The search results are obtained by performing a similarity search on the vector database using the query information corresponding to the text, including one of the following: Searching within the vector database by limiting the search to a search section or search library with a second intent; Searching directly in the vector database using keywords; Searching within the search section or search library by keywords after limiting the search to a search section or search library with a second intent.

[0061] Constructing the prompt words from the search results and the text includes: concatenating the search results and the text according to the prompt word template to obtain the prompt words.

[0062] Furthermore, before obtaining the search results by performing a similarity retrieval in the vector database using the query information corresponding to the text, the method further includes: classifying the text into a domain using a first classification model to determine the domain to which the user instruction belongs; classifying the text into sub-intents using a second classification model within the domain to determine the sub-intents that the user instruction needs to implement within the domain, wherein the sub-intents are used to indicate the user instruction's processing action on cloud resources, and the processing action includes at least one of the following: creation, query, modification, and deletion; classifying the text into a specific intent using a third classification model within the sub-intents to determine the specific intent that the user instruction needs to implement within the sub-intents, wherein the specific intent is used to indicate the execution entity corresponding to the processing action; wherein the hierarchical intent classification model includes: the first classification model, the second classification model, and the third classification model.

[0063] For hierarchical intent classification models, in one case, the hierarchical intent classification model includes a first classification model, a second classification model, and a third classification model, all of which are classification models obtained from a small pre-trained language model through different training sets. Different training sets include a large number of "user statement-intent label" annotation pairs, and the intent label classifications of different training sets are different. For example, the intent label of the first classification model is the domain class, the intent label of the second classification model is the sub-intent class, and the intent label of the third classification model is the specific intent class.

[0064] In another scenario, the hierarchical intent classification model acquisition involves: training a large pre-trained model using a training set (including user statement-intent label pairs) to obtain the main parameters; freezing these main parameters using parameter freezing methods (such as adapter-tuning or low-rank adaptation, or LoRA); and then training a small number of additional "adapter" parameters for each downstream task (such as domain classification or sub-intent classification). In this case, the hierarchical intent classification model is a large pre-trained model that includes both the main parameters and the adapter parameters.

[0065] In use, a large pre-trained model with main parameters supports multiple classification tasks by loading different adapters as different classification models (including the first classification model, the second classification model and the third classification model mentioned above).

[0066] Through the embodiments of this application, by employing a hierarchical classification model to perform deep semantic understanding of user commands and combining it with similarity retrieval of vector databases, the system can construct highly contextualized prompt words, which greatly improves the accuracy and effectiveness of large-scale language models in parsing user natural language commands in the field of private cloud resource management, while ensuring the system's response speed and resource efficiency.

[0067] In an exemplary embodiment, after executing the cloud management task in the ordered task list, the method further includes: upon completion of the execution of the cloud management task in the ordered task list, providing feedback to the user on the execution result of the user instruction; classifying the current case into a target case library based on the user's explicit and implicit feedback on the execution result, wherein the target case library includes: a positive case library and an error case library, and the current case is the case to which the user instruction and the execution result belong; and optimizing the hierarchical intent classification model using the target case library.

[0068] In an exemplary embodiment, executing cloud management tasks in the ordered task list includes: mapping each cloud management task in the ordered task list to execution logic corresponding to each cloud management task through a mapping table, wherein the mapping table is used to indicate the correspondence between cloud management tasks and execution logic, and the execution logic is used to indicate the method name or application interface endpoint for executing each cloud management task; converting semantic parameters of each cloud management task into numerical parameters; and determining the time consumption level of each cloud management task; and executing each cloud management task through the execution logic, the numerical parameters, and the time consumption level.

[0069] A mapping table can be a simple dictionary, a database table, or a dynamically discoverable service registry. The mapping table defines the correspondence between the identifier (or simply `intent_create_vm`) of each fine-grained intent (i.e., each cloud management task) and the specific backend execution logic (such as the `VirtualMachineService.create()` method or a specific API endpoint).

[0070] Furthermore, executing each cloud management task through execution logic, the numerical parameters, and the time consumption level includes: when the time consumption level is long, determining to asynchronously call the execution logic through the numerical parameters to execute each cloud management task; when the time consumption level is short, determining to synchronously call the execution logic through the numerical parameters to execute each cloud management task; wherein, long time consumption refers to the case where the execution time is expected to be greater than a preset time, and short time consumption refers to the case where the execution time is expected to be less than the preset time.

[0071] Furthermore, after executing each cloud management task through the execution logic, the numerical parameters, and the time consumption level, the method further includes: when the execution logic is called asynchronously, providing the user with a unique task identifier for each cloud management task; providing the user with the current status of each cloud management task based on the unique task identifier at a preset period; or, receiving a query request from the user based on the unique task identifier regarding the current status of each cloud management task; and responding to the query request by providing the user with the current status of each cloud management task.

[0072] In an exemplary embodiment, after executing the cloud management task in the ordered task list, the method further includes: upon completion of the execution of the cloud management task in the ordered task list, obtaining an interaction log corresponding to the user instruction, wherein the interaction log includes: the user instruction and the execution result of the cloud management task in the ordered task list; calculating the precision and recall of the large language model through multiple interaction logs; and determining the model performance of the large language model through the harmonic mean of the precision and the recall.

[0073] In other words, the accuracy and recall of a large language model can be determined through multiple interaction logs, and the performance of the large language model can be evaluated by the harmonic mean of accuracy and recall.

[0074] In an exemplary embodiment, before matching the text corresponding to the received user instruction with a first dictionary to determine the processing object that is allowed to process the user instruction, the method further includes: performing text standardization on the user instruction to obtain standardized text corresponding to the user instruction, wherein the text standardization includes: language detection, format cleaning, and format conversion; performing privacy filtering on the standardized text to obtain de-identified text; and expanding the de-identified text to obtain the text corresponding to the user instruction.

[0075] Furthermore, the standardized text is subjected to privacy filtering to obtain de-identified text, including: matching the sensitive information format in the standardized text using a second regular expression, detecting sensitive words in the standardized text using a second dictionary, and identifying specific entities in the standardized text belonging to the cloud resource environment using a named entity recognition model, wherein the specific entities include: project name; and de-identifying the sensitive information format, the sensitive words, and the specific entities using predefined placeholders to obtain de-identified text.

[0076] The second dictionary is a sensitive word dictionary, containing terms related to security, passwords, and account permissions. It includes sensitive information formats such as Internet Protocol (IP) addresses, access keys, and password formats. It also includes unique entities such as project names and personal names within a private cloud environment. The predefined placeholder is [MASKED_A], where A represents content that needs to be de-identified. For example, if the project name in the private cloud environment that needs de-identification is "Phoenix Project," then the corresponding placeholder is [MASKED_PROJECT].

[0077] Furthermore, the de-identified text is expanded to obtain the text corresponding to the user instruction, including: determining the set of synonyms for the keywords through the unique identifiers corresponding to the keywords in the de-identified text; determining the entity relationships corresponding to the cloud resource entities included in the text, wherein the entity relationships include: hierarchical relationships and attribute relationships; and determining the text through the set of synonyms and the entity relationships.

[0078] The hierarchical and attribute relationships include, for example, "hard disk" being a mountable component of "virtual machine" and "bandwidth" being an attribute of "network". Determining the text through the synonym set and the entity relationships includes: identifying the anonymized text, the synonym set, and the entity relationships as the text.

[0079] To better understand the execution process of the above-mentioned cloud management task, the implementation flow of the above-mentioned cloud management task execution method will be described below in conjunction with optional embodiments, but this is not intended to limit the technical solution of the embodiments of this application.

[0080] With the widespread adoption of cloud computing technology, private clouds have become the core of the IT infrastructure for many large and medium-sized enterprises. Private cloud environments support critical business operations, and their scale and complexity are increasing daily, encompassing tens of thousands of resource instances across computing, storage, networking, and security. Traditional cloud management primarily relies on graphical user interfaces (GUIs) and command-line interfaces (CLIs). While GUIs are intuitive, handling batch, repetitive, or complex operational tasks often requires users to click through numerous menus and forms, resulting in low efficiency. Although CLIs are powerful and support automated scripting, they require operators to memorize a large number of precise commands and parameters, leading to a steep learning curve and making them extremely unfriendly to non-professionals. Therefore, improving the human-computer interaction efficiency and experience of cloud management platforms and lowering the barrier to entry has become a pressing technical challenge for the industry.

[0081] Against this backdrop, introducing Natural Language Interaction (NLI) technology into the field of cloud management has become a promising development direction. Users expect to be able to give instructions to the system in everyday language, just like communicating with people, such as "create a 4-core, 8GB test server" or "query the 5 virtual machines with the highest CPU usage last week," thereby achieving more efficient and user-friendly cloud resource management.

[0082] However, achieving a stable and reliable cloud-based natural language intent recognition system faces significant challenges. Early attempts were primarily based on keyword matching or template systems with fixed rules. These systems are simple to implement and have fast response times, but their generalization ability is extremely poor. They cannot handle colloquialisms, synonym substitutions, or slightly complex sentence structures, resulting in a rigid interactive experience and limited practicality.

[0083] In recent years, the rise of pre-trained models, represented by Large Language Models (LLMs), has brought revolutionary breakthroughs to natural language understanding. Some existing technical solutions attempt to directly leverage the powerful capabilities of general-purpose LLMs to parse user cloud management commands. A typical implementation involves sending the user's raw input, either directly or after simple packaging, to a large language model, requesting the model to output a structured JavaScript Object Notation (JSON) object containing the operation intent and required parameters. A large language model refers to a deep learning model trained on large-scale data, possessing powerful natural language understanding and generation capabilities. In other words, the LLM-based cloud management approach in related technologies can be summarized as a "centralized intent recognition method based on a single large language model." The typical process of this method is: receiving user input, calling the LLM to extract intent and parameters, and converting the JSON returned by the LLM into an API call.

[0084] While centralized intent recognition methods based on a single large language model offer significant improvements in flexibility and depth of understanding user intent compared to traditional rule-based methods, they suffer from several serious drawbacks in the specific scenario of private clouds:

[0085] Defect 1: The contradiction between high cost and high performance: The inference process of LLM requires huge computing resources. In a private cloud environment, calling LLM for every interaction will lead to extremely high operating costs and hardware overhead, which runs counter to the cost control requirements of private cloud customers. At the same time, LLM response usually has a delay of seconds, which cannot meet the real-time requirements of users for high-frequency, simple queries (such as checking status).

[0086] Defect 2: Insufficient Security and Controllability: Directly exposing user input to a generic LLM poses security risks. On one hand, user input may unintentionally contain sensitive information such as passwords and keys; on the other hand, in a private cloud environment, many operations (such as deleting virtual machines or modifying network policies) are high-risk and irreversible. The LLM may generate unexpected high-risk operation instructions (such as deleting a production database) due to misunderstandings. In the absence of pre-emptive security reviews and filtering mechanisms, this "black box" processing flow is highly susceptible to causing serious production incidents.

[0087] Defect 3: Insufficient accuracy in intent recognition: Cloud management commands are highly domain-specific and rigorous. User-input natural language often suffers from ambiguity, multiple intents, colloquialisms, and cross-language expression, making it difficult for the system to accurately and completely understand the user's true operational intent. For example, the simple command "Give me a test machine" may involve the specification definition and configuration of various resources such as computing, storage, and network.

[0088] Defect 4: Domain Adaptability and Knowledge Limitations: While general-purpose LLMs possess broad knowledge, they lack "native knowledge" regarding proprietary terminology, internal project designations, and API details specific to private cloud environments. When user commands involve this native knowledge, the LLM's recognition accuracy drops significantly. Although a few examples can be injected through prompt engineering, this is insufficient to systematically address the problem and incurs high maintenance costs.

[0089] Defect 5: Lack of Closed-Loop Optimization Capability: This type of simple LLM call flow is typically an open-loop system. It cannot effectively collect genuine user feedback, nor can it perform attribution analysis and systematic learning on cases of incorrect identification, preventing the system from continuously evolving and iterating during use. Cloud platform functions and user needs are constantly evolving, and intent recognition systems must possess continuous learning and adaptive capabilities. Traditional systems based on fixed rules or models struggle to dynamically adapt to new business scenarios, terminology, and user habits, leading to a decline in system availability over time.

[0090] In summary, while related technologies leverage the advantages of LLM, they fail to fully consider the unique requirements of private cloud environments in terms of security, cost, real-time performance, and adaptability. Simply using LLM as the sole intent recognition engine results in a fragile, expensive, and insecure system. Therefore, a novel and systematic architectural design is urgently needed to capitalize on the strengths and mitigate the weaknesses of LLM, fully leveraging its intelligence while overcoming its inherent limitations to achieve a truly suitable natural language intent recognition system for private cloud production environments.

[0091] To address the aforementioned deficiencies, the primary objective of the optional embodiments of this application is to provide a natural language intent recognition system (hereinafter referred to as the system, used to execute the "cloud management task execution method" in the above embodiments) based on a layered pipeline architecture for private cloud environments. This system, through a multi-layered and modular design, collaboratively utilizes various techniques such as fast matching, lightweight models, retrieval enhancement, and large-scale model inference to achieve rapid, accurate, and secure recognition of user intent, while simultaneously considering system performance, operating costs, and self-learning evolution capabilities, thereby improving the intelligent management level and user experience of the private cloud platform.

[0092] Specifically, such as Figure 3As shown, one optional embodiment of this application's natural language intent recognition system for private cloud environments adopts a layered pipeline and modular design. User-input natural language commands (equivalent to user commands in the above embodiments) are sequentially processed through a unified preprocessing layer, a fast routing layer, a secure pre-filtering layer, a domain classification and fine-grained intent recognition layer, and a task assignment and execution control layer, ultimately forming executable task commands (equivalent to cloud management tasks in the above embodiments). The recognition process is continuously optimized through feedback and self-learning layers. Simultaneously, a comprehensive monitoring and measurement system permeates all layers of the system to ensure its stability and observability.

[0093] The functions of each of the above levels are as follows:

[0094] The system comprises the following layers: a unified preprocessing layer for standardizing, cleaning, and performing preliminary semantic enhancement on raw user input; a fast routing layer for quickly identifying and routing simple, clear instructions using efficient matching algorithms; a security pre-filtering layer for identifying and blocking high-risk operational intentions before deep parsing; a domain classification and fine-grained intent recognition layer, serving as the core intelligent hub of the system, for performing deep semantic understanding and task decomposition on complex and ambiguous instructions; a task dispatch and execution control layer for converting identified intents into standardized calls to backend services and managing their execution lifecycle; a feedback and self-learning layer for collecting processing results and user feedback to drive iterative optimization of system rules and models; and a monitoring and measurement system for comprehensive monitoring of the operational status and performance indicators at all levels of the system.

[0095] The following provides a more detailed explanation of each of the above levels:

[0096] 1. The unified preprocessing layer is the entry point for the entire intent recognition pipeline. Its core responsibility is to transform heterogeneous and unstructured natural language inputs (equivalent to user commands in the above embodiments) from different users and channels into a standardized data stream with unified format, clean content, and normalized semantics, laying a solid foundation for accurate analysis and processing in subsequent layers. This layer mainly includes a text standardization module, a security and privacy filtering module, and a multilingual lemma reconstruction and synonym expansion module.

[0097] 1.1 The text standardization module is responsible for performing a series of deterministic text cleaning and formatting operations, including:

[0098] 1) Language Detection: First, the system uses a lightweight language recognition library (e.g., based on an n-gram statistical model) to determine the main language of the input text (e.g., Chinese, English). This information will be used to guide subsequent lemmatization and synonym expansion.

[0099] 2) Format cleaning and conversion: The system executes a series of preset cleaning rules, including but not limited to:

[0100] Full-width / half-width conversion: Converts full-width characters (such as "VM", "10G") in the input text to half-width characters (such as "VM", "10G") to ensure consistency in keyword matching. Virtual Machine (VM) is a specific type of virtual machine.

[0101] Case uniformity: Based on language characteristics, English characters are usually converted to lowercase, unless specific terms (such as proprietary product names) require case retention.

[0102] Noise reduction: Remove special symbols, emojis, and redundant punctuation marks that do not affect the core semantics. For example, change "Help me check the status of the virtual machine!!!" to "Help me check the status of the virtual machine".

[0103] Standardized Time / Number Formatting: Converts non-standard time, date, and number expressions described in text into a machine-readable standardized format. For example, "tomorrow morning at 10:00" combined with the current date context is converted to "YYYY-MM-DD10:00:00"; "two hundred" is converted to "200".

[0104] 1.2 The security and privacy filtering module proactively identifies and de-identifies potential privacy data and security credentials (resulting in de-identified text) before the text enters the core processing logic, in order to prevent the leakage of sensitive information in a private cloud environment. Specifically, this includes:

[0105] 1) Pattern matching based on regular expressions (equivalent to the second regular expression in the above embodiments): The system has a built-in extensible regular expression rule base for matching common sensitive information formats, such as IP addresses, access keys, passwords, API tokens, email addresses, and phone numbers. Once a match is successful, the system will replace the original text with predefined placeholders (such as `[MASKED_IP]`, `[MASKED_SECRET]`).

[0106] 2) Sensitive word filtering: The system maintains a dynamically updated sensitive word dictionary (equivalent to the sensitive word dictionary in the above embodiment), containing words related to security, passwords, account permissions, etc. When these words are detected, the system can take measures such as blocking, issuing alarms, or de-identifying the words.

[0107] 3) Privacy protection based on Named Entity Recognition (NER): To more intelligently identify privacy information in the context, the system adopts a lightweight Named Entity Recognition model. This model is specifically trained to identify unique entities in a private cloud environment, such as user names, project names, department names, etc. For example, for the input "Please add the permissions of 'Zhang San' to the 'Phoenix Project'", the system can identify that 'Zhang San' is a person's name and 'Phoenix Project' is a project name, and replace them with `[MASKED_USER]` and `[MASKED_PROJECT]`, thus protecting the specific information from being recorded or learned by subsequent components such as large models while retaining the sentence structure and intention.

[0108] 1.3. The multi - language lemmatization and synonym expansion module is dedicated to solving the problems of "same meaning but different forms" and "cross - language" expressions. Its core is to construct and maintain a domain knowledge graph or a terminology knowledge base. This module is used to improve the recall rate and robustness of intention recognition, specifically including:

[0109] 1) Construction of the terminology knowledge base: The system builds a structured knowledge base to store professional terms, aliases, abbreviations, and multi - language correspondences in the cloud management domain. For example:

[0110] Synonyms / aliases: Map expressions such as "virtual machine", "cloud host", "virtual instance", "VM", "instance", etc. to a unique internal identifier `entity_virtual_machine`.

[0111] Language mapping: Associate the Chinese "create" with the English "create", "provision", "build", etc.

[0112] Hierarchical and attribute relationships: Define the relationships between entities. For example, "hard disk" is a mountable component of "virtual machine", and "bandwidth" is an attribute of "network".

[0113] 2) Lemmatization: For languages such as English, the system uses lemmatization technology to unify different forms of words (such as "restarting", "restarted", "restarts") into their basic form ("restart"), reducing the number of keyword variants that need to be matched.

[0114] 3) Synonym Expansion: When processing input, the system queries a terminology knowledge base to expand keywords in the text (such as "cloud host") into its set of all known synonyms ("virtual machine," "VM," etc.). This expanded information can be used for subsequent fast route matching or as feature input to a classification model, enabling the system to understand diverse user expressions. For example, even if a user enters "Give me an instance," the system can accurately understand their intent to create a virtual machine through synonym expansion.

[0115] After passing through a unified preprocessing layer, the raw natural language input is transformed into a structured data object containing cleaned text, language identifiers, masked privacy information, and semantically expanded lists of keywords and entities. This object is then passed to the next layer of the pipeline.

[0116] 2. The fast routing layer is a key design element for achieving high system performance and low cost. Its goal is to quickly identify and process most simple, high-frequency user requests using efficient, low-latency matching algorithms without invoking complex models. This layer is similar to a network switch, precisely directing traffic to designated processing units, thereby significantly reducing average response time and minimizing the consumption of expensive computing resources. This layer mainly includes a keyword and domain detection module and a static whitelist matching module.

[0117] 2.1 The keyword and domain detection module focuses on identifying instructions with clear domain specificity and directly routing them to the corresponding business processing agent. In a private cloud agent scenario, this typically means dispatching requests to a "cloud resource management agent," "intelligent reporting agent," or "monitoring and alarm agent." Specifically, this includes:

[0118] 1) Dynamic Keyword Dictionary (equivalent to the first dictionary in the above embodiments): The system maintains a keyword dictionary strongly related to the business domain. This dictionary is dynamically configurable, and administrators can add, delete, modify, and query keywords at any time according to business changes. The keywords in the dictionary are associated with the aforementioned terminology knowledge base and automatically include synonyms and multilingual expressions. For example:

[0119] In the field of intelligent reporting, this includes "reports", "charts", "expenses", "bills", "cost analysis", and "monthly reports".

[0120] The monitoring and alarm field includes "monitoring", "alarms", "logs", "performance", "CPU utilization", "network traffic", etc.

[0121] The field of cloud resource management includes "virtual machines", "hard disks", "networks", "creation", "deletion", and "configuration".

[0122] 2) Efficient matching algorithm: To achieve fast detection, the system adopts an optimized multi-pattern matching algorithm, such as the Aho-Corasick automaton. This algorithm can scan the input text at once and match all the keywords in the dictionary simultaneously. Its time complexity is linear with the text length and independent of the number of keywords, ensuring extremely high matching efficiency.

[0123] 3) Routing decision logic: Once the input text hits the keywords in a certain or certain fields, the system makes decisions according to the preset routing rules. The rules can set priorities. For example, if both "cost" and "virtual machine" are hit, it can be routed to the intelligent report Agent preferentially. Once the routing decision is successful, the request is directly sent to the target Agent. At the same time, to handle potential complex situations, the original request can be selectively and asynchronously sent into the subsequent deep intention recognition pipeline as a supplementary or verification mechanism. This strategy of "immediate routing and asynchronous deepening" ensures a quick response to simple requests.

[0124] 2.2 The static whitelist matching module is used to handle common greetings and chit-chat that are irrelevant to the core business of cloud management, so as to provide basic conversation capabilities and avoid sending irrelevant questions into complex processing flows, thereby saving resources. Specifically, it includes:

[0125] 1) Q&A whitelist (equivalent to the Q&A whitelist in the above embodiment): The system maintains a configurable whitelist list in the form of key-value pairs of "question pattern - fixed reply". The question pattern can support regular expressions (equivalent to the first regular expression in the above embodiment) to match similar ways of asking questions. For example:

[0126] Pattern `(Hello|hello|hi)`, reply "Hello, I'm your cloud management assistant. How can I help you?"

[0127] Pattern `(Who are you|who are you)`, reply "I'm an intelligent assistant designed to help you manage cloud resources."

[0128] Pattern `(What can you do|what can you do)`, reply "I can help you create, query, manage cloud resources, and provide reports and monitoring information."

[0129] 2) Limited chit-chat strategy: The design concept of this module is "limited support". For inputs that cannot match the whitelist and cannot be recognized as valid cloud management intentions in the subsequent process, the system will uniformly classify them as "unsupported chit-chat" and give a unified and friendly prompt, such as "Sorry, as a cloud resource management assistant, I can't answer this question temporarily." This strategy ensures the professionalism and focus of the agent.

[0130] 3) Access Frequency Statistics and Optimization: The system records the hit frequency of each whitelisted pattern. Frequently hit patterns indicate that they are common user interactions. Furthermore, the system performs cluster analysis on inputs categorized as "unsupported casual chat." If a particular type of unknown question is frequently asked, the system can identify it as a candidate and prompt operations personnel to add it to the whitelist or develop a new feature, thus forming a simple self-optimizing closed loop.

[0131] If a request (equivalent to a user instruction in the above embodiment) is not successfully matched and processed by any module in the fast routing layer, it will be passed to the next layer unchanged, namely the security pre-filtering layer, for more in-depth analysis.

[0132] 3. The security pre-filtering layer is the first proactive line of defense for ensuring the security of private cloud operations. Unlike the privacy filtering in the preprocessing layer, this layer focuses on identifying operations that may have a significant impact on the system state or pose potential risks from the perspective of "intent," and makes pre-judgments based on user identity and permissions. Its purpose is to intercept, reject, or mark obviously illegal or high-risk requests before invoking expensive models for fine-grained intent recognition, thereby reducing security risks and unnecessary resource consumption. This layer mainly includes a lifecycle intent recognition module and a security policy reasoning module.

[0133] 3.1 The lifecycle intent recognition module is specifically designed to identify explicit intents (equivalent to the first intent in the above embodiments) that will alter the lifecycle state of cloud resources. These operations are typically "write" operations and are potentially destructive.

[0134] 1) High-Risk Intent Vocabulary: The system maintains a dedicated vocabulary containing verbs and phrases describing changes in the resource lifecycle. This vocabulary is carefully designed and linked to a terminology knowledge base, covering multilingual expressions. For example:

[0135] Creation categories: "Create", "New", "Activate", "Provision";

[0136] Change categories: "Power on", "Power off", "Restart", "Adjust specifications", "Upgrade", "Downgrade", "Power on", "Reboot", "Resize";

[0137] Deletion categories: "Delete", "Destroy", "Release", "Terminate", "Delete", "Destroy".

[0138] 2) Rule-based rapid identification: Utilizing these keywords, the module performs matching through simple dependency relationships and contextual rules. For example, the rule could be `(verb [delete class]) + (noun [virtual machine entity])`, inferring the intent `intent_delete_vm`. This identification method based on vocabulary and simple syntactic structures, while not as accurate as deep learning models, is sufficient for identifying clear, single lifecycle operations and is extremely fast.

[0139] 3) Pre-emptive Permission Check: Once a high-risk intent is identified, the system immediately performs a preliminary permission check based on the user's identity information in the current session. For example, the system can query cached user role information to determine if the user belongs to the "read-only observer" role. If a "read-only observer" issues a "delete virtual machine" command, the system does not need to perform more complex intent analysis; it can directly reject the request at this stage and return a clear permission deficiency message.

[0140] 3.2 Security Policy Reasoning Module. For intents that pass the initial identification but are still marked as high-risk, the security policy reasoning module will conduct a deeper risk assessment. At its core is a lightweight rules engine.

[0141] 1) Rule Engine and Policy Library: The system has a built-in rule engine that interprets and executes a set of predefined security policies. These policies are described in "IF-THEN" format and can be dynamically configured by the security administrator. The policy inputs (Facts, equivalent to the user's target information in the above embodiment) include:

[0142] User identity: User ID, User Group, Role.

[0143] User historical behavior: For example, the frequency with which the user performed high-risk operations in the past 24 hours.

[0144] IAM permissions: Fine-grained permission policies for the target resource obtained in real time or near real time from the Identity and Access Management (IAM) system.

[0145] The identified preliminary intent (equivalent to the first intent in the above embodiments): the result from the lifecycle intent recognition module.

[0146] Contextual information: For example, whether the current operation is targeting resources in the "production environment" vs. the "test environment".

[0147] The reasoning process and decision-making include: the rule engine matching and reasoning based on the input "facts" and the policy library. For example, the following policy can be defined (equivalent to the security policy in the above embodiment):

[0148] `RULE 1:IF user_role='developer' AND intent='delete_vm' AND resource_env='production' THEN decision='require_approval'`. (If the developer attempts to delete a virtual machine in the production environment, approval is required.)

[0149] `RULE 2:IF user_history_high_risk_ops_freq>10 / hour THEN decision='deny'`. (If a user's high-risk operations are too frequent, the decision will be temporarily rejected.)

[0150] `RULE 3:IF intent='resize_vm' AND user_iam_permission_allow=falseTHEN decision='deny'`. (If IAM permissions explicitly prohibit this operation, then deny it).

[0151] 2) Output Decision: The reasoning result is a clear decision, such as `pass`, `deny`, or `require_approval`. This decision is attached to the request object and passed to the subsequent execution layer. If the decision is `deny`, the entire process terminates prematurely at this point, returning the specific reason for denial to the user. This design places security checks at the forefront, forming a defense-in-depth system that effectively prevents illegal or dangerous instructions from reaching the final execution stage.

[0152] 4. Domain Classification and Fine-Grained Intent Recognition Layer. When a request passes the preceding fast routing and security filtering, or when its intent is relatively ambiguous or complex, it will enter the core intelligent processing layer of this application's optional embodiments, namely the domain classification and fine-grained intent recognition layer. This layer comprehensively utilizes various artificial intelligence technologies to achieve a comprehensive, in-depth, and accurate understanding of the user's true intent. It mainly consists of a hierarchical intent classification model, a large-model inference module with enhanced retrieval, and a multi-intent decomposition and restatement module.

[0153] 4.1 Hierarchical Intent Classification Model. For requests that are not identified by the fast routing layer but do not belong to extremely complex or multi-intent requests, this module uses a series of lightweight machine learning models for efficient classification.

[0154] 1) Hierarchical classification system: Intended to be organized into a tree-like hierarchical structure. For example:

[0155] Top-level (domain classification): Resource management, monitoring and maintenance, cost management, security and compliance.

[0156] The second layer (sub-intention classification): Under the "Resource Management" domain, it can be further divided into "Creating Resources", "Querying Resources", "Modifying Resources", and "Deleting Resources".

[0157] The third layer (specific intent): Under the "Query Resources" sub-intent, it can be divided into "Query Virtual Machine Status", "Query Hard Disk Capacity", "Query Network Bandwidth", etc.

[0158] Lightweight classification model: The system employs small, efficient models deployed locally in a private cloud environment. These models can be: fine-tuned pre-trained models: for example, small pre-trained language models such as BERT-tiny and DistilBERT, corresponding to Bidirectional Encoder Representations from Transformers (BERT), are fine-tuned on specific corpora in the cloud management domain. The fine-tuned dataset contains a large number of "user statement-intent label" pairs.

[0159] Parameter-Efficient Fine-Tuning (PEFT): To further reduce training and deployment costs, techniques such as Adapter-tuning or LoRA (Low-Rank Adaptation) can be employed. These techniques freeze the main parameters of a large pre-trained model, training only a small number of additional "adapter" parameters for each downstream task (such as domain classification or sub-intent classification). This allows the system to support multiple classification tasks using a single base model by loading different adapters, significantly improving resource utilization.

[0160] It should be noted that the security pre-filter layer identifies coarse-grained tags for "high-risk lifecycle write operation intents" (used for interception / approval / release), which is a quick determination of "blocking risks first"; the hierarchical intent classification model identifies fine-grained intents (domain → sub-intent → specific intent) of the entire business, which are used for subsequent parameter extraction and execution routing.

[0161] 2) Classification Process: Upon receiving a request, the system first invokes the top-level classification model to determine its macro-domain. Once the domain is determined (e.g., "resource management"), the system then invokes the next-level classification model corresponding to that domain to determine a more specific sub-intent (e.g., "request resource"). This hierarchical approach breaks down a complex multi-classification problem into multiple simpler sub-problems, which not only improves classification accuracy but also makes model training and maintenance easier.

[0162] 4.2 Retrieval-Augmented Generation (RAG) module.

[0163] For requests with complex contexts, ambiguous referencing, multiple constraints, or requiring external knowledge for comprehension, the system will utilize its most powerful reasoning capability—retrieval-enhanced large model reasoning. This module's design references advanced retrieval enhancement frameworks (such as Language Model as a Retriever and Reader (LARA) framework), but has been deeply customized for private cloud scenarios.

[0164] The core idea of ​​the module is to avoid directly testing the large language model (LLM) without any prior knowledge. Instead, before calling the LLM, it retrieves the most relevant background information, examples, and context from a specially constructed knowledge base. This information is then fed to the LLM along with the original question, thereby greatly improving the accuracy, relevance, and controllability of the LLM's answer.

[0165] The workflow includes:

[0166] 1) Candidate Intent Generation: First, the hierarchical intent classification model mentioned above, or a smaller, pre-defined generative model, can be used to perform a preliminary analysis of the user input, generating a set of possible candidate intents or keywords to be queried. It should be noted that the hierarchical intent classification model can output a distribution of candidate intents (top-k intents), while the generative model can produce both candidate intents and search keywords / entities (or both). The hierarchical intent classification model typically uses the top-k (including confidence) domain / sub-intents / specific intents as candidate intents, rather than just a single final label.

[0167] 2) Vectorized Retrieval: The system converts these candidate intents or keywords into vector representations, and then performs similarity retrieval in a pre-built vector database. This vector database stores:

[0168] Historical dialogues: Successful user interaction cases from the past, containing the complete chain of "question-intent-parameter-answer".

[0169] API Documentation and Knowledge Base: API interface documentation, parameter descriptions, user manuals, and best practice documentation for all components of the private cloud platform. These unstructured documents are segmented into chunks and stored in a vectorized format.

[0170] 3) Context-Aware Prompt Construction: The system combines the most relevant few-shots retrieved with the original user input, following a carefully designed template, to create a rich prompt. For example, a prompt might include the following:

[0171] Role definition: "You are a private cloud management expert...";

[0172] Related API examples: [Parameter descriptions of the retrieved `create_vm` API];

[0173] Similar question-and-answer pairs: [Retrieved historical dialogue: "User asked 'Build a smaller virtual machine', the system interpreted it as `create_vm(size='small')`"];

[0174] Current task: "Now, please parse the following user request: '...', and output its corresponding intent and parameters."

[0175] 4) Controlled LLM Inference: Finally, this enhanced prompt (equivalent to the prompt word in the above embodiments) is sent to a large language model (which can be a locally deployed open-source model or a cloud service). Because the prompt contains rich and highly relevant contextual information, the LLM can more accurately understand the user's vague expression (such as "small virtual machine") and map it to specific API parameters.

[0176] 4.3 Multi-intent decomposition and restatement module.

[0177] When a user expresses multiple actions in a sentence, this module is responsible for breaking them down into a series of independent, executable subtasks.

[0178] Multi-intent detection: Leveraging the powerful semantic understanding capabilities of LLM or through syntactic analysis, the system detects whether the input contains multiple parallel or consecutive actions. For example, "Create a 2-core, 4GB virtual machine for me, then mount a 100GB solid-state drive (SSD), and finally add it to the 'Web server' cluster."

[0179] Task Decomposition: Once multiple intents are detected, the LLM breaks down this complex instruction into an ordered list of tasks. This list is typically represented in a structured format (such as JSON), clearly defining the type and parameters of each subtask, as well as their dependencies. For the example above, the output might be:

[0180] json [

[0182] {"task_id":1,"intent":"create_vm","params":{"cpu":2,"memory_gb":4}},

[0183] {"task_id":2,"intent":"create_disk","params":{"size_gb":100,"type":"ssd"}},

[0184] {"task_id":3,"intent":"attach_disk","params":{"vm_ref":"task_1_result","disk_ref":"task_2_result"}},

[0185] {"task_id":4,"intent":"add_to_cluster","params":{"vm_ref":"task_1_result","cluster_name":"Web server"}} ]

[0187] ```

[0188] Problem Restatement and Clarification: In some cases, a user's original question may be unclear or ambiguous. Drawing on practices similar to Amazon Web Services (AWS) Conversational Data Assistant, the model can first "restate" or "clarify" the original question, generating a more standardized and explicit version for user confirmation. For example, if a user asks, "Check which machines spent the most money last month," the system can restate it as: "Okay, do you want to query the list of the top 10 virtual machines in descending order of resource consumption in the last calendar month?" This interactive clarification mechanism ensures the accuracy of subsequent execution and avoids erroneous results due to misunderstandings.

[0189] 5. Task (equivalent to cloud management tasks in the above embodiments) assignment and execution control layer.

[0190] After the user's natural language intent is accurately identified and structured, the task assignment and execution control layer is responsible for translating these logical "intents" into actual calls to backend cloud management platform services, and for robustly managing and controlling the entire execution process. This layer acts as a bridge between "understanding" and "action," ensuring the reliability, idempotency, and traceability of operations. It mainly includes modules such as intent-to-module routing, idempotency control and transaction management, human-in-the-loop approval, and asynchronous task processing.

[0191] 5.1 The intent-to-module routing module dispatches the structured intents output by the fine-grained intent recognition layer to the correct backend execution modules.

[0192] Intent-Executor Mapping Table: The system maintains a mapping table (which can be a simple dictionary, a database table, or a dynamically discoverable service registry) that defines the correspondence between each fine-grained intent ID (such as `intent_create_vm`) and the specific backend execution logic (such as the `VirtualMachineService.create()` method or a specific API endpoint).

[0193] Parameter Adaptation and Conversion: Before calling the backend service, this module also performs parameter adaptation and conversion. The parameters output by the intent recognition layer may be semantic (e.g., `size='large'`), while the backend API may require specific numerical values ​​(e.g., `cpu=8, memory=16`). This module will convert these semantic parameters into the precise format required by the API according to predefined rules or configurations.

[0194] Synchronous vs. Asynchronous Call Decision: Based on the nature of the intent, the routing module decides whether to call the executor synchronously or asynchronously. For query-type, short-duration operations, synchronous calls are typically used, and the results are waited for directly. For longer-duration write operations such as creation and deletion, asynchronous calls are used, and the task is submitted to a subsequent asynchronous thread pool for processing.

[0195] 5.2 Idempotent Control and Transaction Management Module. To ensure the reliability and consistency of write operations, this module introduces key control mechanisms.

[0196] 1) Idempotency Control: For all write operations (create, modify, delete), the system generates a unique idempotency key before dispatching the task. This key is typically a combination of the user ID, session ID, and a hash of the request content. This key is sent to the backend service along with the API request. Before executing the operation, the backend service checks whether this idempotency key has been processed recently. If so, it does not repeat the operation but directly returns the result of the previous execution. This effectively prevents duplicate operations caused by network retries, repeated user clicks, etc., such as avoiding the creation of multiple identical virtual machines.

[0197] 2) Transaction Management and Task Pipeline: For complex operations consisting of multiple subtasks (such as the multi-intent decomposition results mentioned above), this module uses a task pipeline or similar mechanism for management.

[0198] Atomicity guarantee: For scenarios requiring strong consistency, multiple operations can be wrapped in a single database transaction.

[0199] Eventual consistency (Saga pattern): For time-consuming distributed operations spanning multiple services, the system adopts the Saga pattern. The main control flow sequentially calls the executors of each subtask. If a subtask fails, the system calls a series of predefined "compensating transactions" to roll back the completed preceding steps. For example, in the process of "creating a virtual machine and mounting a hard disk," if mounting the hard disk fails, the compensating transaction is to automatically delete the newly created virtual machine, thereby ensuring the eventual consistency of the system state.

[0200] 5.3 Human-in-the-Loop Module. For high-risk operations marked as `require_approval` in the security pre-filter layer, or operations that require secondary confirmation according to the policy, this module will interrupt the automatic execution process and introduce manual intervention.

[0201] Approval workflow startup: When a task requiring approval is received, the execution control layer does not immediately call the backend API, but instead sets the task status to "Pending Approval" and persists it.

[0202] Notification and Approval Interface: The system sends notifications to pre-defined approvers or approval groups via integrated messaging channels (such as WeChat Work, DingTalk, and email). The notification includes detailed information about the operation (operator, operation content, risk level) and a link for approval. The approver can access a secure approval interface through this link to view details and make a "approve" or "reject" decision.

[0203] Execution Resumption and Timeout: The execution control layer subscribes to approval results. Once an "approval" signal is received, it reactivates the task and continues execution. If a "rejection" signal is received or no response is received within a preset time (approval timeout), the task will be canceled, and the initiating user will be notified.

[0204] 5.4 Asynchronous Thread Pool and Heartbeat Mechanism. To handle time-consuming background tasks and provide users with real-time progress feedback, this module adopts an asynchronous processing architecture.

[0205] Task Submission and Thread Pool: For asynchronous tasks, the task dispatcher submits them to a dedicated, isolated background thread pool or message queue. The main interaction thread can immediately return a unique task ID to the user, informing them that "the task has been submitted and is being executed in the background," thus avoiding frontend request timeouts or UI lag.

[0206] Heartbeats and Status Updates: Workers executing tasks in the background periodically report their progress to a central state store (such as Redis or a database). These reports are called "heartbeats." Heartbeat information includes the task's current status (such as "resources requested," "environment configuration in progress," "75% complete") and the estimated remaining time.

[0207] Progress Inquiry and Feedback: The user's front-end interface can periodically poll a dedicated API using the task ID to check the latest status of the task. Based on heartbeat information, the system displays a dynamic, real-time progress bar or status update to the user, greatly improving the user experience for long-running tasks.

[0208] 6. Feedback and self-learning layer.

[0209] To enable the intent recognition system to continuously evolve and self-optimize, an optional embodiment of this application designs a feedback and self-learning layer. This layer collects and analyzes data and user feedback during system operation, forming a closed loop to continuously improve the system's rules, models, and knowledge base, enabling it to dynamically adapt to new business needs and user habits. This layer mainly includes an intent recognition evaluation and feedback collection module, a whitelist and rule automatic expansion module, and a dynamic participation and model optimization module.

[0210] 6.1 Intent Recognition Evaluation and Feedback Collection Module. This module forms the data foundation for self-learning, responsible for systematically collecting and measuring the performance of intent recognition, and obtaining explicit or implicit user feedback.

[0211] 1) Performance Metrics Logging: For each interaction, the system logs a complete record, including: the original input, preprocessing results, decisions made by each module (e.g., whether the fast route was hit), the finally identified intent and parameters, and the final execution result. Based on these logs, the system automatically calculates key performance indicators (KPIs), such as:

[0212] Accuracy: The percentage of interactions in which the system correctly identifies the intended message.

[0213] Recall: The percentage of interactions in which the user's true intent is X that are successfully identified as X by the system.

[0214] F1 score: the harmonic mean of precision and recall, used to comprehensively evaluate model performance.

[0215] 2) User feedback collection:

[0216] Explicit feedback: After certain interactions, the system can proactively display a simple feedback interface to the user, such as, "I performed the 'Restart Virtual Machine A' operation for you. Did this operation meet your expectations? [Yes] / [No, I actually wanted to...]". User-initiated corrections and evaluations represent the highest quality labeled data.

[0217] Implicit feedback: The system infers user satisfaction by analyzing user behavior. For example, if a user immediately performs an undo or correct action after an action, it may suggest that the previous intent recognition was incorrect. Conversely, if a user continues to interact more deeply based on the query results after a query, it indicates that the intent recognition was likely accurate.

[0218] 3) Error Case Library: All identified errors or cases explicitly corrected by users are automatically collected into a dedicated "Error Case Library." This database provides valuable material for manual review and model iteration.

[0219] 6.2 Whitelist and Automatic Rule Expansion Module. This module uses collected data to intelligently maintain and expand the "hard rules" in the system.

[0220] Small talk whitelist expansion: The system periodically performs cluster analysis on inputs that are not identified by any intent and are ultimately categorized as "unsupported small talk." If it finds that a certain type of similar question (such as "How's the weather today?") occurs frequently, the system can automatically generate a new whitelist suggestion rule and push it to the operations and maintenance personnel's review queue. Once approved by the operations and maintenance personnel, the rule takes effect, thereby gradually expanding the system's scope of small talk knowledge.

[0221] Security and Routing Rule Optimization: By analyzing the error case library, the system can discover vulnerabilities in existing rules. For example, if a new, risky expression (such as using slang to describe a delete operation) is found to bypass the security pre-filtering layer, the system can suggest generating a new keyword rule or security policy. Similarly, if requests in a certain domain are consistently misrouted or misclassified, the system can also suggest adjusting the keyword dictionary of the fast routing layer.

[0222] 6.3 Dynamic Partitioning and Model Tuning Module. This module is the core of the system's self-learning capability at the model level, responsible for continuous model iteration and intelligent scheduling.

[0223] Automated Model Retraining: The system can be configured with a periodic automated process that uses a "few-case library" and user-verified correct cases as incremental training data to retrain the hierarchical intent classification model. This allows the model to continuously learn new expressions and business intents while maintaining its accuracy.

[0224] A / B Testing and Model Version Management: To safely deploy new models, the system supports A / B testing or canary releases. For example, 10% of user traffic can be directed to the newly trained model version, while 90% of traffic continues to use the old model. By comparing the performance metrics (accuracy, latency, etc.) of the two versions under real traffic, a decision can be made on whether to fully deploy the new model. The system also supports model version control and one-click rollback to ensure the stability of the iteration process.

[0225] Dynamic routing strategy adjustment: In some advanced application scenarios, the system can even introduce reinforcement learning or multi-armed bandit algorithms to dynamically adjust the priority of different recognition paths. For example, the system might discover that for a request containing the word "report," the success rate of directly using the large model inference with retrieval enhancement (although slower) is much higher than going through the classification model first. Thus, the system can learn a strategy: when a specific keyword is detected, dynamically adjust the internal processing pipeline to select the optimal path, thereby achieving a better balance between accuracy and latency.

[0226] 7. Monitoring and measurement system.

[0227] To ensure the stable, efficient, and transparent operation of the entire intent recognition system in a complex private cloud environment, this application's optional embodiments design a comprehensive monitoring and measurement system that spans all levels. This system not only focuses on the final business results but also delves into every aspect of the system, providing data support for troubleshooting, performance optimization, and capacity planning. It primarily includes end-to-end metric monitoring, layered diagnostics and logging, as well as deployment and evolution strategy support.

[0228] 7.1 End-to-end metrics monitoring. This module measures the overall performance and health of the system from the user's perspective.

[0229] 1) Key Performance Indicators (KPIs): The system displays the following key indicators in real time through a centralized monitoring dashboard:

[0230] Overall accuracy of intent recognition: The percentage of the final intent given by the system that matches the user's true intent (confirmed through feedback or manual annotation).

[0231] Average Response Time (ART): The average time taken from receiving user input to returning an initial response (acknowledgment or execution result). Typically, its P95 and P99 quantiles are monitored to evaluate the long-tail performance of the system.

[0232] LLM call-related metrics include: total number of calls to the large language model, average token consumption per call, API call cost (if using external services), and call failure rate. These metrics directly relate to the system's operating costs.

[0233] Task execution success rate: The percentage of tasks assigned to the execution layer that are ultimately successfully completed.

[0234] 2) Alarm system: When any core indicator exceeds the preset threshold (for example, accuracy is below 95%, or P99 response time exceeds 5 seconds), the monitoring system will automatically trigger an alarm to notify the operation and maintenance team.

[0235] 7.2 Layered Diagnostics and Logging. To enable rapid fault location and bottleneck analysis, this module establishes independent and detailed monitoring and logging for each layer of the pipeline.

[0236] 1) Layered performance indicators:

[0237] Preprocessing layer: The average time to process each request.

[0238] Fast routing layer: Keyword routing hit rate, casual chat whitelist hit rate. A high hit rate indicates that this layer is effective.

[0239] Security pre-filtering layer: the number of times high-risk intents are triggered, the number of blocked requests, and the reasons.

[0240] Fine-grained intent recognition layer: Confusion matrix of hierarchical classification model, used to analyze which intents are easily confused; retrieval recall and precision of retrieval enhancement module; format correctness of LLM output content.

[0241] Execution control layer: average execution time of each type of task, task failure rate, and average waiting time for manual approval.

[0242] 2) Distributed Tracing and Logging: The system employs distributed tracing technology (such as OpenTelemetry). Each user request is assigned a unique Trace ID upon entering the system. This ID persists throughout the entire processing flow across all levels, modules, and even backend services. All relevant logs, metrics, and error messages are associated with this Trace ID. When a problem occurs, operations personnel only need a single Trace ID to trace the entire lifecycle of the request, significantly improving troubleshooting efficiency.

[0243] 7.3 Deployment and Evolution Strategy Support. This module ensures that the system's iteration and upgrade process is smooth and controllable, minimizing the impact on business operations.

[0244] Modular and Independent Deployment: The architecture of the optional embodiments of this application is highly modular, with each layer, and even each module within a layer, considered as an independent microservice or component. This means that any part of the system can be independently upgraded, scaled up, or replaced without redeploying the entire system. For example, the rule base of the security pre-filtering layer can be updated separately, or a new intent classification model can be replaced.

[0245] Canary Release and Rolling Update: The system supports canary release and rolling update mechanisms. When a new version of a module (e.g., a newly trained model) is ready to go live, it can be deployed to a small number of servers initially, handling only a small amount of user traffic. The monitoring system closely compares the performance of the old and new versions under real traffic. Only when all the metrics of the new version meet expectations will the traffic ratio be gradually increased until it eventually completely replaces the old version.

[0246] Online configuration and policy switching: Most system behaviors can be dynamically configured and adjusted online without redeployment. For example, keywords for fast routing can be updated in real time, security policy thresholds can be adjusted, the default version of the large language model can be switched, or an experimental feature can be enabled or disabled with a single click. This flexibility enables the system to respond quickly to business changes and unexpected events.

[0247] Version control and rollback: All models, rules, configurations, and code are subject to strict version control. If a newly released version encounters serious problems, the deployment system supports one-click rollback to the previous stable version, ensuring high availability and fault recovery capabilities.

[0248] Through the collaborative work of the above seven levels, the system and method proposed in the optional embodiments of this application can efficiently, securely and intelligently solve the problem of natural language intent recognition in private cloud management within a unified, closed-loop framework, thereby providing a solid technical foundation for realizing the next generation of intelligent cloud management platforms.

[0249] To make the objectives, technical solutions, and advantages of the optional embodiments of this application clearer, the technical solutions of the optional embodiments of this application will be described in detail below with reference to a specific embodiment. This specific embodiment simulates a typical user interaction scenario, demonstrating the entire process from the user inputting natural language commands to the system completing the corresponding cloud resource operation.

[0250] Scene setting:

[0251] A development engineer, username `dev_li`, wanted to create a virtual machine for stress testing the backend of a web application in a project called "phoenix-project". He entered the following command into the interactive interface of the cloud management platform that deployed the system of the optional embodiment of this application: "Hello, please start a high-configuration stress testing machine for me in the 'phoenix project', using Ubuntu 22.04, and then add it to the backend Virtual Private Cloud (VPC) network."

[0252] The system execution flow is as follows:

[0253] Step 1: Unified preprocessing layer processing.

[0254] 1) Text Standardization: The system receives the raw input. The text standardization module performs cleaning, unifying Chinese quotation marks “'” and “'” into half-width quotation marks, and unifying uppercase letters in “Ubuntu 22.04” into lowercase (assuming this is the strategy), resulting in the preliminarily cleaned text: “Hello, please start a high-configuration load testing machine for me in the 'Phoenix Project', using Ubuntu 22.04, and then add it to the backend VPC network.”

[0255] 2) Security and Privacy Filtering: The NER-based privacy protection module is activated. Since "Project Phoenix" is labeled as a project name entity in the system's knowledge base, the system may anonymize it as `[MASKED_PROJECT]` to prevent project information from being leaked to any subsequent external LLM calls. However, in this embodiment, it is assumed that the internal LLM is secure, so the original text is retained to obtain a more precise context.

[0256] 3) Multilingual word form restoration and synonym expansion: The terminology knowledge base plays a role.

[0257] The word “start” has been expanded to a set of synonyms {“start”, “create”, “activate”, “provision”, “create”}.

[0258] "Benchmark" is identified as an alias for "virtual machine" and mapped to the internal identifier `entity_virtual_machine`, along with the tag `usage=benchmark`.

[0259] "Higher configuration" was identified as a vague specification description.

[0260] The “VPC network” is mapped to `entity_vpc`.

[0261] This step enriches the original input into a structured data object, containing standardized text and expanded semantic tags.

[0262] Step 2: Fast routing layer processing.

[0263] 1) Keyword and Domain Detection: The input text contains keywords such as "virtual machine," "create," and "VPC network," all of which point to the "cloud resource management" domain. However, the instruction contains multiple actions and a vague description ("configure a little higher"), which does not conform to the characteristics of a simple and clear instruction.

[0264] 2) Static whitelist matching: If the beginning of the command, "Hello", matches the chat whitelist, the system can respond with a friendly "Hello!", but this will not interrupt the subsequent core intent processing flow.

[0265] Because the complexity of the instruction exceeded the processing capacity of the fast routing, the request was passed to the next layer in its entirety.

[0266] Step 3: Safety pre-filter layer treatment.

[0267] 1) Lifecycle Intent Recognition: Based on the combination of "startup" (and its synonym "create") and "virtual machine", the module quickly identifies that this is a lifecycle change intent of `intent_create_vm`, which belongs to a high-risk "write" operation.

[0268] 2) Security Policy Reasoning: The rule engine starts and collects the following "facts":

[0269] `user_id`:`dev_li`;

[0270] `user_role`: `developer` (obtained from the IAM system);

[0271] `preliminary_intent`:`create_vm`;

[0272] `target_project`:`phoenix-project`.

[0273] The engine matches rules from the security policy library, such as: `RULE: IF user_role='developer' AND intent='create_vm' AND target_project LIKE '-project' THEN decision='pass'`. This rule allows developers to create virtual machines within regular projects. If the inference decision is `pass`, the request is allowed.

[0274] Step 4: Domain Classification and Fine-Grained Intent Recognition Layer Processing. Due to the complexity of the request and the presence of ambiguous descriptions, the system decides to enable the Retrieval Enhanced Large Model Inference (RAG) module.

[0275] 1) Candidate intent and keyword generation: The system performs preliminary analysis and generates keywords to be searched: "Create virtual machine", "High configuration", "Ubuntu 22.04", "Join VPC network", "Phoenix Project".

[0276] It should be noted that the standardization in the preprocessing stage of this application embodiment is not to force all fields to be lowercase, but to standardize in layers according to token type, and retain the original value for accurate alignment and echoing.

[0277] 2) Vectorized retrieval: The system retrieves these keywords from the vector database.

[0278] The API documentation for `create_vm` was retrieved, which explains the necessary parameters such as `image_id`, `flavor_id`, and `network_id`.

[0279] Historical interaction data was retrieved, including a user who said "a larger machine", which the system interpreted as a successful case of `flavor_id='flavor-large-cpu'`.

[0280] The knowledge base entry found is "Ubuntu 22.04" with the corresponding `image_id` as `img-ubuntu-2204-lts`.

[0281] The metadata for "Phoenix Project" was retrieved, and its associated backend VPC network ID is `vpc-phoenix-backend`.

[0282] 3) Context-Aware Hint Construction: The system combines the retrieved information and the original request into a detailed hint for the LLM, the structure of which may be as follows:

[0283] You are a cloud management expert. Based on the provided API information and similar cases, parse the user's request.

[0284] Related API: create_vm(name,image_id,flavor_id,network_id).

[0285] Similar case: User: "Build a larger machine", parsing: create_vm(flavor_id='flavor-large-cpu').

[0286] Knowledge Base Information: "Ubuntu 22.04"->image_id:'img-ubuntu-2204-lts'; "Phoenix Project" backend VPC->network_id:'vpc-phoenix-backend'; "High configuration" usually refers to CPU-intensive packages, such as 'flavor-large-cpu'.

[0287] Now, please break down the following user request into a series of structured task instructions and output them in JSON format:

[0288] "Please set up a high-configuration load testing machine for me in the 'Phoenix Project,' running Ubuntu 22.04, and then add it to the backend VPC network."

[0289] 4) Multi-Intent Decomposition and LLM Inference: Upon receiving this information-rich prompt, the LLM performs inference and task decomposition. Since the instruction contains two actions, "create" and "join network," the LLM decomposes it into two ordered subtasks. It outputs the following JSON object:

[0290] json

[0291] {

[0292] "summary":"This creates a high-configuration Ubuntu 22.04 load testing virtual machine for you in the 'Phoenix Project' and joins it to the backend VPC network."

[0293] "tasks":[

[0294] {

[0295] "task_id":1,

[0296] "intent":"create_vm",

[0297] "params":{

[0298] "name":"benchmark-vm-dev-li-01",

[0299] "image_id":"img-ubuntu-2204-lts",

[0300] "flavor_id":"flavor-large-cpu",

[0301] "project":"phoenix-project"

[0302] }

[0303] },

[0304] {

[0305] "task_id":2,

[0306] "intent":"attach_network",

[0307] "params":{

[0308] "vm_ref":"result_of_task_1",

[0309] "network_id":"vpc-phoenix-backend"

[0310] },

[0311] "depends_on":1

[0312] } ]

[0314] }

[0315] ```

[0316] Step 5: Task assignment and execution control layer processing.

[0317] 1) Intent-to-Module Routing: The controller receives the above JSON. It first displays the contents of the `summary` field to the user for confirmation, or directly begins execution.

[0318] 2) Idempotency Control and Transaction Management: The system generates a unique idempotent key for the entire operation. Since multiple tasks exist, the system initiates a Saga transaction flow.

[0319] 3) Asynchronous task execution:

[0320] Task 1 (`create_vm`): The controller calls the internal `VirtualMachineService`, passing in the parameters for Task 1. This is a time-consuming operation, so the system immediately returns a task ID to the user and prompts "The virtual machine creation task has started...". The worker thread performs the creation in the background.

[0321] Heartbeat and Status Updates: The created Worker periodically reports its status: "Allocating computing resources...", "Installing operating system...".

[0322] Task 2 (`attach_network`): After Task 1 is successfully completed, the Saga coordinator captures the success event and obtains the ID of the newly created virtual machine. It triggers Task 2, which calls `NetworkService` to add the virtual machine to the network with the ID `vpc-phoenix-backend`.

[0323] 4) Result feedback: After all tasks are successful, the system updates the overall task status to "success" and notifies the user `dev_li` via a message: "The virtual machine `benchmark-vm-dev-li-01` has been successfully created and joined to the backend network."

[0324] Step 6: Feedback and self-learning layer processing.

[0325] 1) Intent Recognition, Evaluation, and Feedback Collection: The entire interaction chain is recorded, including the original input, the JSON output of the LLM, and the execution result. After the system provides the user with the final notification, a feedback button is attached: "[Did the operation meet your expectations?]".

[0326] 2) Model Tuning: Assuming the user clicks "[Yes]", this data pair from the original input to the successfully parsed JSON is marked as a high-quality positive sample. At some point in the future, when the system triggers the automatic model retraining process, this sample will be used to fine-tune the intent classification model or serve as a prime example for future RAG retrieval, enabling the system to handle similar requests like "create a high-configuration virtual machine" more accurately and quickly in the future.

[0327] Through the above implementation methods, the system proposed in the optional embodiments of this application successfully transforms a complex and ambiguous natural language instruction into a series of specific cloud operations in a safe, accurate, and efficient manner, forming a data closed loop that can be learned and optimized in the future.

[0328] Compared with related technologies, the natural language intent recognition system and method based on a layered pipeline architecture for private cloud environments proposed in the optional embodiments of this application have the following significant advantages:

[0329] 1. Significantly Improved Interaction Efficiency and User Experience: Optional embodiments of this application elevate human-computer interaction from cumbersome graphical interface clicks and rigid command-line input to fluent and efficient natural language dialogue. Users can complete complex cloud management tasks using everyday language without specialized training. For example, an operation like "create and configure a virtual machine," which requires traversing multiple GUI pages and filling in dozens of fields, can now be completed with a single sentence. This greatly lowers the barrier to entry for cloud platforms and improves the work efficiency of various personnel, from developers and testers to operations and maintenance staff.

[0330] 2. Balancing high precision and low cost for superior economic efficiency: The optional embodiments of this application feature a unique layered pipeline architecture, particularly the design of the fast routing layer. This architecture can offload and quickly process the vast majority (typically over 80%) of simple, high-frequency query and operation commands without invoking expensive large language models (LLMs). Only for truly complex and ambiguous intents will the system activate LLMs for deep inference. This intelligent scheduling strategy, which prioritizes efficient resource allocation, significantly reduces system computational resource consumption and operating costs compared to existing technologies that invoke LLMs for every interaction, while ensuring millisecond-level responses for simple requests. This perfectly aligns with the core requirements of cost control and performance in private cloud environments.

[0331] 3. Significantly Enhanced Operational Security and Controllability: Private cloud environments have far higher security requirements than public clouds. The security pre-filtering layer designed in the optional embodiments of this application constitutes the system's first line of proactive security defense. Through upfront high-risk intent identification and policy reasoning linked with IAM, it can effectively intercept a large number of potential misoperations and unauthorized requests before the intent enters the core parsing stage. In addition, the manual in-loop approval mechanism introduced for high-risk operations, as well as the idempotent control and transaction rollback capabilities of the execution layer, together constitute a defense-in-depth system, minimizing the destructive consequences caused by the ambiguity of natural language and ensuring the stability and reliability of the production environment.

[0332] 4. Continuous self-learning and dynamic adaptation capabilities: The functions of the cloud platform and users' expression habits are constantly evolving. The feedback and self-learning layer designed in the optional embodiments of this application forms a complete closed-loop optimization system by systematically collecting user feedback and analyzing error cases. It can not only automatically fine-tune the intent recognition model using new data, making it "smarter with use," but also intelligently suggest expanding the casual chat whitelist and optimizing routing / security rules. This continuous evolution capability ensures the high availability and accuracy of the system during long-term operation, avoiding the value decay caused by "knowledge obsolescence" in traditional static systems.

[0333] 5. Improved robustness in understanding complex and multi-intent instructions: Through an innovative Retrieval Enhancement Generation (RAG) module and multi-intent decomposition capabilities, the optional embodiments of this application can accurately understand complex instructions containing multiple operations, ambiguous referencing, or domain-specific knowledge. Before invoking the LLM, the system proactively retrieves relevant API documentation, historical cases, and knowledge bases, providing the LLM with ample "contextual ammunition," greatly improving its parsing accuracy in the specialized domain of private clouds. This enables the optional embodiments of this application to handle complex tasks involving multiple dependent steps, such as "creating a virtual machine, then mounting a hard drive, and finally adding it to a security group," which is difficult to achieve with simple rules or single LLM invocation methods.

[0334] In summary, the optional embodiments of this application, through their innovative system architecture and technical solutions, have successfully achieved an ideal balance between the convenience of natural language interaction and the stringent requirements of the private cloud environment (security, cost, performance, and controllability), providing a solid technical foundation and a clear implementation path for building the next generation of intelligent and user-friendly cloud management platforms.

[0335] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods according to the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk), and includes several instructions to cause a terminal device (which may be a mobile phone, computer, server, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0336] This embodiment also provides a cloud management task execution device, which is used to implement the above embodiments and preferred embodiments, and will not be repeated hereafter. Although the device described in the following embodiments is preferably implemented in software, hardware implementation, or a combination of software and hardware, is also possible and contemplated.

[0337] Figure 4 This is a framework diagram of an execution device for cloud management tasks according to an embodiment of this application, such as... Figure 4 As shown, the device includes:

[0338] The matching module 42 is used to match the text corresponding to the received user instruction with the first dictionary to determine the processing object that is allowed to process the user instruction, wherein the first dictionary is associated with the business domain of the cloud management task;

[0339] The module 44 is configured to, when it is determined that the processing object includes a large language model and the risk decision for the first intent of the user instruction is a first value, construct the prompt words of the large language model based on the text and a preset vector database, so as to obtain an ordered task list corresponding to the user instruction output by the large language model, wherein the first value is used to indicate that the first intent passes the risk detection;

[0340] Execution module 46 is used to execute cloud management tasks in the ordered task list.

[0341] The cloud management task execution device described above matches the text corresponding to the received user instruction with a first dictionary to determine the processing object allowed to process the user instruction. The first dictionary is associated with the business domain of the cloud management task. If the processing object is determined to include a large language model, and the risk decision for the first intent of the user instruction is a first value, prompt words for the large language model are constructed based on the text and a preset vector database to obtain an ordered task list corresponding to the user instruction output by the large language model. The first value indicates that the first intent passes risk detection. The cloud management task in the ordered task list is then executed. This application solves the problem that cloud management methods in related technologies mainly rely on graphical user interfaces and command-line interfaces for management, resulting in complex operations and low efficiency, thus improving cloud management efficiency.

[0342] In an exemplary embodiment, the matching module 42 is further configured to: determine, if the text matches a question on the question-answering whitelist in the question-answering component using a first regular expression, that the processing object allowed to process the user instruction includes the question-answering component; determine, if the user instruction is not a complex instruction and the text matches a target keyword in the first dictionary, that the processing object allowed to process the user instruction includes a business processing agent; and determine, if the user instruction is a complex instruction or the text does not match a target keyword in the first dictionary, that the processing object allowed to process the user instruction includes a large language model.

[0343] In an exemplary embodiment, the matching module 42 is further configured to: match the text with the first dictionary using a multi-pattern matching algorithm to determine the target keyword matched by the text in the first dictionary, wherein the first dictionary is used to record the target keyword and is also used to indicate the correspondence between the target keyword and the business domain of the cloud management task; make decisions on multiple business domains corresponding to the target keyword according to preset routing rules, wherein the preset routing rules are used to indicate the routing priority corresponding to the multiple business domains respectively; determine the target intelligent agent indicated by the decision result as the processing object, wherein the target intelligent agent is the business processing intelligent agent corresponding to the business domain with the highest routing priority among the multiple business domains, and the multiple business domains each correspond to different business processing intelligent agents.

[0344] In an exemplary embodiment, the apparatus further includes a risk assessment module, configured to identify a first word in the text describing changes in the lifecycle of cloud resources before constructing prompt words for the large language model based on the text and a preset vector database to obtain an ordered task list corresponding to the user instruction output by the large language model; identify a first word in the text describing changes in the lifecycle of cloud resources using a preset vocabulary, wherein the preset vocabulary includes verbs and phrases describing changes in the lifecycle of cloud resources; match the first word with a second word corresponding to a cloud resource entity included in the text to determine the first intent; and perform a risk assessment on the first intent using a rule engine to determine a risk decision for the first intent.

[0345] In an exemplary embodiment, the risk assessment module is further configured to determine the dependency relationship between the first word and the second word in the text, and the context rules corresponding to the first word and the second word in the text, wherein the context rules are used to indicate the association relationship between modifiers and a third word in the text, the third word including: the first word and the second word; and to obtain the first intent by matching the first word and the second word through the dependency relationship and the context rules.

[0346] In an exemplary embodiment, the risk assessment module is further configured to obtain target information of the user who initiated the user instruction, wherein the target information includes: user identity, user historical behavior, user permissions, and the first intent; and to match the target information with predefined security policies within the rule engine to determine a risk decision regarding the first intent.

[0347] In an exemplary embodiment, module 44 is further configured to perform a similarity search in the vector database using the query information corresponding to the text, and obtain a search result. The vector database includes: first vector data and second vector data, wherein the first vector data is vector data corresponding to the historical dialogue between the user and the large language model, and the second vector data is vector data corresponding to the component information of all components of the cloud resource; wherein the query information includes: the second intent of the text determined by the hierarchical intent classification model and / or the keywords of the text generated by the preset generation model; and the prompt words are constructed using the search result and the text.

[0348] In an exemplary embodiment, module 44 is further configured to classify the text into domains using a first classification model to determine the domain to which the user instruction belongs; classify the text into sub-intents using a second classification model under the domain to determine the sub-intents that the user instruction needs to implement under the domain, wherein the sub-intents are used to indicate the user instruction's processing action on cloud resources, and the processing action includes at least one of the following: creation, query, modification, and deletion; classify the text into specific intents using a third classification model under the sub-intents to determine the specific intent that the user instruction needs to implement under the sub-intents, wherein the specific intents are used to indicate the execution entity corresponding to the processing action; wherein the hierarchical intent classification model includes: the first classification model, the second classification model, and the third classification model.

[0349] In an exemplary embodiment, the apparatus further includes: an optimization module, configured to, after executing a cloud management task in the ordered task list and upon completion of the cloud management task in the ordered task list, provide feedback to the user on the execution result of the user instruction; classify the current case into a target case library based on the user's explicit and implicit feedback on the execution result, wherein the target case library includes: a positive case library and an error case library, and the current case is the case to which the user instruction and the execution result belong; and optimize the hierarchical intent classification model using the target case library.

[0350] In an exemplary embodiment, the execution module 46 is further configured to map each cloud management task in the ordered task list to the execution logic corresponding to each cloud management task through a mapping table, wherein the mapping table is used to indicate the correspondence between cloud management tasks and execution logic, and the execution logic is used to indicate the method name or application interface endpoint for executing each cloud management task; convert the semantic parameters of each cloud management task into numerical parameters; determine the time consumption level of each cloud management task; and execute each cloud management task through the execution logic, the numerical parameters, and the time consumption level.

[0351] In an exemplary embodiment, the execution module 46 is further configured to, when the time consumption level is long, determine to asynchronously call the execution logic through the numerical parameters to execute each cloud management task; and when the time consumption level is short, determine to synchronously call the execution logic through the numerical parameters to execute each cloud management task; wherein, long time consumption refers to the case where the execution time is expected to be greater than a preset time, and short time consumption refers to the case where the execution time is expected to be less than the preset time.

[0352] In one exemplary embodiment, the apparatus further includes: a feedback module, configured to, after executing each cloud management task through execution logic, the numerical parameters, and the time consumption level, provide a unique task identifier for each cloud management task to the user in the case of asynchronous invocation of the execution logic; provide feedback to the user on the current status of each cloud management task based on the unique task identifier at a preset period; or, receive a query request from the user on the current status of each cloud management task based on the unique task identifier; and, in response to the query request, provide feedback to the user on the current status of each cloud management task.

[0353] In one exemplary embodiment, the apparatus further includes: a performance determination module, configured to, after executing a cloud management task in the ordered task list and upon completion of the execution of the cloud management task in the ordered task list, acquire an interaction log corresponding to the user instruction, wherein the interaction log includes: the user instruction and the execution result of the cloud management task in the ordered task list; calculate the precision and recall of the large language model using multiple interaction logs; and determine the model performance of the large language model using the harmonic mean of the precision and the recall.

[0354] In one exemplary embodiment, the apparatus further includes: a preprocessing module, configured to match the text corresponding to the received user instruction with a first dictionary to determine the processing object that is allowed to process the user instruction, perform text standardization on the user instruction to obtain standardized text corresponding to the user instruction, wherein the text standardization includes: language detection, format cleaning and format conversion; perform privacy filtering on the standardized text to obtain de-identified text; and expand the de-identified text to obtain the text corresponding to the user instruction.

[0355] In an exemplary embodiment, the preprocessing module is further configured to match the sensitive information format in the standardized text using a second regular expression, detect sensitive words in the standardized text using a second dictionary, and identify specific entities in the standardized text belonging to the cloud resource environment using a named entity recognition model, wherein the specific entities include: project name; and to desensitize the sensitive information format, the sensitive words, and the specific entities using predefined placeholders to obtain desensitized text.

[0356] In an exemplary embodiment, the preprocessing module is further configured to determine a set of synonyms for the keywords using unique identifiers corresponding to the keywords in the de-identified text; determine the entity relationships corresponding to the cloud resource entities included in the text, wherein the entity relationships include hierarchical relationships and attribute relationships; and determine the text using the set of synonyms and the entity relationships.

[0357] For a description of the features in the embodiment corresponding to the execution device for cloud management tasks, please refer to the relevant description in the embodiment corresponding to the execution method for cloud management tasks, which will not be repeated here.

[0358] Embodiments of this application also provide an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to perform the steps in any of the cloud management task execution method embodiments described above.

[0359] Embodiments of this application also provide a computer-readable storage medium storing a computer program, wherein the computer program is configured to execute the steps in any of the above-described cloud management task execution method embodiments when running.

[0360] In one exemplary embodiment, the aforementioned computer-readable storage medium may include, but is not limited to, various media capable of storing computer programs, such as a USB flash drive, read-only memory (ROM), random access memory (RAM), portable hard disk, magnetic disk, or optical disk.

[0361] Embodiments of this application also provide a computer program product, which includes a computer program that, when executed by a processor, implements the steps in any of the cloud management task execution method embodiments described above.

[0362] Embodiments of this application also provide another computer program product, including a non-volatile computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps in any of the above-described cloud management task execution method embodiments.

[0363] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0364] The above provides a detailed description of a cloud management task execution method provided in this application. Specific examples have been used to illustrate the principles and implementation methods of this application. The descriptions of the above embodiments are only intended to help understand the method and core ideas of this application. It should be noted that those skilled in the art can make various improvements and modifications to this application without departing from its principles, and these improvements and modifications also fall within the protection scope of the claims of this application.

Claims

1. A method for executing cloud management tasks, characterized in that, include: The text corresponding to the received user instruction is matched with a first dictionary to determine the processing object that is allowed to process the user instruction. The first dictionary is associated with the business domain of the cloud management task. The first dictionary is a dictionary that includes keywords from different business domains. When it is determined that the processing object includes a large language model and the risk decision for the first intent of the user instruction is a first value, the prompt words of the large language model are constructed based on the text and a preset vector database to obtain an ordered task list corresponding to the user instruction output by the large language model, wherein the first value is used to indicate that the first intent passes the risk detection. Execute the cloud management tasks from the ordered task list. Before constructing prompt words for the large language model based on the text and a preset vector database to obtain an ordered list of tasks corresponding to the user instruction output by the large language model, the method further includes: The system identifies a first vocabulary in the text that describes changes in the lifecycle of cloud resources using a pre-defined vocabulary, wherein the pre-defined vocabulary includes verbs and phrases describing changes in the lifecycle of cloud resources. The first vocabulary is then matched with a second vocabulary corresponding to cloud resource entities included in the text to determine a first intent. Finally, a rule engine performs a risk assessment on the first intent to determine a risk decision regarding the first intent. The prompt words for constructing the large language model based on the text and a preset vector database include: The similarity search is performed on the vector database using the query information corresponding to the text to obtain the search results. The vector database includes: first vector data and second vector data. The first vector data is vector data corresponding to the historical dialogue between the user and the large language model, and the second vector data is vector data corresponding to the component information of all components of the cloud resources. The query information includes: the second intent of the text determined by the hierarchical intent classification model and / or the keywords of the text generated by the preset generation model. The prompt words are constructed using the search results and the text. Executing cloud management tasks from the ordered task list includes: Each cloud management task in the ordered task list is mapped to the corresponding execution logic using a mapping table. The mapping table indicates the correspondence between cloud management tasks and execution logic, and the execution logic indicates the method name or application interface endpoint for executing each cloud management task. The semantic parameters of each cloud management task are converted into numerical parameters, and the time consumption of each cloud management task is determined. Each cloud management task is then executed using the execution logic, the numerical parameters, and the time consumption.

2. The method for executing cloud management tasks according to claim 1, characterized in that, The text corresponding to the received user instruction is matched with a first dictionary to determine the processing object that is allowed to process the user instruction, including: If the text is determined to match a question on the question-and-answer whitelist in the question-and-answer component using the first regular expression, then the question-and-answer component is determined to be the processing object that is allowed to process the user instruction. If the user instruction is not a complex instruction and the text matches the target keyword in the first dictionary, the processing object allowed to process the user instruction is determined to include the business processing intelligent agent. If the user instruction is a complex instruction, or if the text does not match the target keyword in the first dictionary, the processing objects allowed to process the user instruction include large language models.

3. The method for executing cloud management tasks according to claim 2, characterized in that, The text corresponding to the received user instruction is matched with a first dictionary to determine the processing object that is allowed to process the user instruction, including: The text is matched with the first dictionary using a multi-pattern matching algorithm to determine the target keywords that the text matches in the first dictionary. The first dictionary is used to record the target keywords and also to indicate the correspondence between the target keywords and the business domain of the cloud management task. The decision is made on multiple business domains corresponding to the target keyword according to preset routing rules, wherein the preset routing rules are used to indicate the routing priority corresponding to each of the multiple business domains; The target intelligent agent indicated by the decision result is determined as the processing object, wherein the target intelligent agent is the business processing intelligent agent corresponding to the business domain with the highest routing priority among the multiple business domains, and each of the multiple business domains corresponds to a different business processing intelligent agent.

4. The method for executing cloud management tasks according to claim 1, characterized in that, Matching the first word with the second word corresponding to the cloud resource entity included in the text to determine the first intent includes: Determine the dependency relationship between the first word and the second word in the text, and the context rules corresponding to the first word and the second word in the text, wherein the context rules are used to indicate the association relationship between modifiers and a third word in the text, and the third word includes: the first word and the second word; The first intent is obtained by matching the first word and the second word through the dependency relationship and the context rule.

5. The method for executing cloud management tasks according to claim 1, characterized in that, The first intent is assessed for risk using a rules engine to determine a risk decision regarding the first intent, including: Obtain target information of the user who initiated the user instruction, wherein the target information includes: user identity, user history behavior, user permissions, and the first intent; The target information is matched with predefined security policies within the rule engine to determine a risk decision regarding the first intent.

6. The method for executing cloud management tasks according to claim 1, characterized in that, Before obtaining the search results by performing a similarity search on the vector database using the query information corresponding to the text, the method further includes: The text is classified into domains using a first classification model to determine the domain to which the user instruction belongs; The text is classified into sub-intents using a second classification model in the domain to determine the sub-intents that the user instruction needs to implement in the domain. The sub-intents are used to indicate the user instruction's processing action on cloud resources, and the processing action includes at least one of the following: creation, query, modification, and deletion. The text is classified into specific intentions using a third classification model under the sub-intention, so as to determine the specific intention that the user instruction needs to achieve under the sub-intention, wherein the specific intention is used to indicate the execution entity corresponding to the processing action; The hierarchical intent classification model includes: the first classification model, the second classification model, and the third classification model.

7. The method for executing cloud management tasks according to claim 1, characterized in that, After executing the cloud management tasks in the ordered task list, the method further includes: Once the cloud management tasks in the ordered task list have been completed, the execution result of the user's command will be fed back to the user. The current case is categorized into the target case library based on the user's explicit and implicit feedback on the execution result. The target case library includes a positive case library and an error case library. The current case is the case to which the user instruction and the execution result belong. The hierarchical intent classification model is optimized using the target case library.

8. The method for executing cloud management tasks according to claim 1, characterized in that, Each cloud management task is executed by executing the logic, the numerical parameters, and the time consumption level, including: If the time consumption level is considered to be long, it is determined that the execution logic will be asynchronously invoked using the numerical parameters to execute each cloud management task; If the time consumption is short, the execution logic is synchronously invoked using the numerical parameters to execute each cloud management task. Among them, long execution time refers to the case where the execution time is expected to be longer than the preset time, and short execution time refers to the case where the execution time is expected to be shorter than the preset time.

9. The method for executing cloud management tasks according to claim 8, characterized in that, After executing each cloud management task by means of the execution logic, the numerical parameters, and the time consumption level, the method further includes: In the case of asynchronous invocation of the execution logic, a unique task identifier for each cloud management task is returned to the user; The system will provide feedback to the user on the current status of each cloud management task based on the unique task identifier according to a preset period. Alternatively, the system may receive a query request from a user based on the unique task identifier regarding the current status of each cloud management task; and in response to the query request, provide feedback to the user regarding the current status of each cloud management task.

10. The method for executing cloud management tasks according to claim 1, characterized in that, After executing the cloud management tasks in the ordered task list, the method further includes: When the cloud management tasks in the ordered task list have been completed, the interaction log corresponding to the user instruction is obtained, wherein the interaction log includes: the user instruction and the execution result of the cloud management tasks in the ordered task list; The accuracy and recall of the large language model are calculated using multiple interaction logs. The model performance of the large language model is determined by the harmonic mean of the accuracy and the recall.

11. The method for executing cloud management tasks according to claim 1, characterized in that, Before matching the text corresponding to the received user instruction with a first dictionary to determine the processing object that is allowed to process the user instruction, the method further includes: The user instruction is subjected to text standardization to obtain the standardized text corresponding to the user instruction. The text standardization includes: language detection, format cleaning and format conversion. The standardized text is then subjected to privacy filtering to obtain de-identified text; The de-identified text is expanded to obtain the text corresponding to the user instruction.

12. The method for executing cloud management tasks according to claim 11, characterized in that, The standardized text is subjected to privacy filtering to obtain de-identified text, including: The standardized text is matched for sensitive information formats using a second regular expression, sensitive words are detected using a second dictionary, and specific entities belonging to the cloud resource environment are identified using a named entity recognition model. The specific entities include: project name. The sensitive information format, sensitive words, and specific entities are desensitized using predefined placeholders to obtain desensitized text.

13. The method for executing cloud management tasks according to claim 11, characterized in that, Expanding the de-identified text to obtain the text corresponding to the user instruction includes: The set of synonyms for the keywords is determined by the unique identifiers corresponding to the keywords in the de-identified text; Determine the entity relationships corresponding to the cloud resource entities included in the text, wherein the entity relationships include: hierarchical relationships and attribute relationships; The text is determined by the set of synonyms and the entity relationships.

14. A device for executing cloud management tasks, characterized in that, include: A matching module is used to match the text corresponding to the received user instruction with a first dictionary to determine the processing object that is allowed to process the user instruction. The first dictionary is associated with the business domain of the cloud management task. The first dictionary is a dictionary that includes keywords from different business domains. The module is configured to, when determining that the processing object includes a large language model and that the risk decision for the first intent of the user instruction is a first value, construct prompt words for the large language model based on the text and a preset vector database, so as to obtain an ordered task list corresponding to the user instruction output by the large language model, wherein the first value is used to indicate that the first intent passes the risk detection; The execution module is used to execute cloud management tasks in the ordered task list. The device further includes a risk assessment module, configured to identify a first term in the text describing changes in the lifecycle of cloud resources using a preset vocabulary, wherein the preset vocabulary includes verbs and phrases describing changes in the lifecycle of cloud resources; match the first term with a second term corresponding to cloud resource entities included in the text to determine the first intent; and perform a risk assessment on the first intent using a rule engine to determine a risk decision regarding the first intent. The obtaining module is further configured to perform a similarity search in the vector database using the query information corresponding to the text, and obtain search results. The vector database includes: first vector data and second vector data, wherein the first vector data is vector data corresponding to the historical dialogue between the user and the large language model, and the second vector data is vector data corresponding to the component information of all components of the cloud resources. The query information includes: the second intent of the text determined by a hierarchical intent classification model and / or keywords of the text generated by a preset generation model. The prompt words are constructed using the search results and the text. The execution module is further configured to map each cloud management task in the ordered task list to the corresponding execution logic of each cloud management task through a mapping table, wherein the mapping table is used to indicate the correspondence between cloud management tasks and execution logic, and the execution logic is used to indicate the method name or application interface endpoint for executing each cloud management task; convert the semantic parameters of each cloud management task into numerical parameters; determine the time consumption of each cloud management task; and execute each cloud management task through the execution logic, the numerical parameters, and the time consumption.

15. An electronic device, characterized in that, include: Memory, used to store computer programs; A processor, configured to execute the computer program to implement the steps of the execution method for the cloud management task as described in any one of claims 1 to 13.

16. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program, wherein when the computer program is executed by a processor, it implements the steps of the execution method of the cloud management task as described in any one of claims 1 to 13.

17. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the execution method for the cloud management task as described in any one of claims 1 to 13.

Images