A method for automatically collecting server performance metrics using intelligent agents based on large models

Abstract

This invention discloses a method for automatically collecting server performance metrics using an intelligent agent based on a large model. The method includes: receiving a user-inputted maintenance requirement description in natural language; generating a structured collection instruction containing the type of performance metric to be collected and time parameters; dynamically generating an executable automation script adapted to the target server based on the structured collection instruction; and converting the raw output stream into standardized data objects for transmission to a data analysis module. The technical solution of this application automatically generates and executes a collection script adapted to the target server through natural language interaction, achieving full-process automation from collection and analysis to diagnostic suggestions, thus improving maintenance efficiency and intelligence.

Description

Technical Field

[0001] This invention relates to the technical field of server operation and maintenance, and in particular to a method for automatically collecting server performance indicators based on a large model-based intelligent agent. Background Technology

[0002] As the core of modern information systems, servers bear the critical tasks of data storage, processing, and transmission. Their performance stability and operational efficiency directly affect the reliability of the entire business system. To ensure stable server operation, continuous monitoring of its performance indicators is crucial. Indicators such as CPU utilization, memory usage, disk I / O rate, and network bandwidth are core bases for quantitatively assessing server health, conducting capacity planning, fault early warning, and performance optimization. Therefore, achieving accurate, timely, and comprehensive performance indicator collection has become an indispensable foundational aspect of server operation and maintenance.

[0003] Currently, traditional methods for collecting server performance metrics mainly rely on two modes. The first is manual configuration of collection scripts, requiring operations and maintenance personnel to possess strong programming skills and familiarity with specific server operating system environments. This involves manually writing Shell, PowerShell, and other script commands. This manual configuration process is not only inefficient and repetitive, but also highly susceptible to human error, leading to invalid or erroneous data collection and failing to meet the needs of managing large-scale, heterogeneous server clusters. The second method uses specific monitoring tools. While these offer some encapsulation and simplification, their functionality is often fixed and rigid, lacking sufficient flexibility. These tools typically cannot understand complex natural language operational instructions and struggle to respond quickly and dynamically to diverse temporary and customized needs. Existing methods generally suffer from a disconnect between collection and analysis. Most only handle data collection and simple display, lacking in-depth intelligent analysis capabilities of the collected results. They cannot automatically diagnose potential faults and generate operational suggestions, resulting in a long cycle from problem discovery to resolution. The overall intelligence level of the operational process needs significant improvement. How to properly solve the above problems has become an urgent issue for the industry. Summary of the Invention

[0004] This invention provides a method for automatically collecting server performance indicators based on a large model intelligent agent. It is used to automatically generate and execute collection scripts adapted to the target server through natural language interaction, realizing full-process automation from collection and analysis to diagnostic suggestions, thereby improving operation and maintenance efficiency and intelligence level.

[0005] According to a first aspect of the present invention, a method for automatically collecting server performance metrics by an intelligent agent based on a large model is provided, the method comprising: The system receives a description of operation and maintenance requirements in natural language input from the user, performs semantic parsing on the description of operation and maintenance requirements based on a pre-set large language model, extracts the identity information of the target server, the type of performance indicators to be collected, and the time parameters of the collection task, and generates a structured collection instruction containing the type of performance indicators to be collected and the time parameters accordingly. According to the structured collection instructions, a matching basic script template is retrieved from the connected knowledge base based on the type of performance indicator to be collected, and the corresponding operating system environment configuration parameters are obtained according to the identity information of the target server. The basic script template is instantiated and populated using the operating system environment configuration parameters to dynamically generate an executable automated script adapted to the target server. A connection session with the target server is established via a remote secure communication protocol, and the executable automation script is deployed to the target server's runtime environment for execution, capturing the raw output stream generated during script execution in real time. In one embodiment, the step of instantiating and populating the basic script template using the operating system environment configuration parameters to dynamically generate an executable automation script adapted to the target server includes: The operating system environment configuration parameters are parsed to determine the operating system type and kernel version number of the target server, and compatible system call commands or API interface names are filtered from the instruction set of the knowledge base based on the kernel version number; The selected system call commands or API interface names are injected into the reserved function slots of the basic script template to form intermediate script code; Based on the time parameters in the structured acquisition instructions, loop control logic or timed triggering logic is implanted into the intermediate script code, and syntax integrity is checked. After the check passes, the executable automated script is generated.

[0006] In one embodiment, establishing a connection session with the target server via a remote secure communication protocol and distributing the executable automation script to the target server's runtime environment for execution includes: Based on the identity information of the target server, query the asset management list to obtain the corresponding IP address, port number and access credentials, and initiate a connection request for an SSH encrypted channel or WinRM remote management channel accordingly. After the connection session is successfully established, the executable automation script is transferred to the temporary working directory of the target server through the connection session, and the executable automation script is granted execution permissions in the operating system environment. An execution command is sent to trigger the execution of the executable automated script, and the connection session remains active until a signal indicating the end of script execution is received. Subsequently, a cleanup command is sent to delete the script file in the temporary working directory and disconnect the connection.

[0007] In one embodiment, converting the raw output stream into a standardized data object includes: The original output stream is intercepted by character stream, and noise data containing system prompts, newline characters and non-ASCII encoded characters is filtered out by a preset regular expression library to extract effective performance index values. Based on the key-value mapping rules corresponding to the performance metric type, the extracted performance metric values ​​are associated with the collection timestamp and server ID to construct a structured data packet that conforms to the JSON specification. The structured data packet is validated for field types. If the validation passes, the structured data packet is pushed to the input buffer via a message queue or HTTP interface.

[0008] In one embodiment, it also includes: Collect user feedback data on the proposed operation and maintenance solution. The feedback data includes validity markers and user-corrected suggestions. Feature extraction is performed on the evaluation feedback data. If the validity is marked as positive, the executable automated script and the corresponding fault diagnosis rule generated this time are extracted as positive samples. The script template weights and fault feature vectors in the knowledge base are updated and adjusted using the positive samples, so that the processing logic corresponding to the positive samples is given priority when the same type of operation and maintenance requirement description is received in the future.

[0009] In one embodiment, it also includes: Based on the programming language type of the generated automated script, the corresponding static code analysis tool is called to perform syntax checks. Specifically, if the script is in Python, the pyflakes tool is called for checking, and if the script is in Shell, the shellcheck tool is called for checking. Syntax errors are automatically corrected based on the check results. The automated script is scanned. If a high-risk system call instruction is found, the script process is blocked or a secondary confirmation is performed. If hard-coded key information is found, it is automatically replaced with an environment variable reference. Construct a containerized simulation environment that matches the target server's operating system version. Deploy the automation script to the containerized simulation environment for trial operation to verify the validity of the system commands called in the script and the paths to the performance indicator files read in the target environment. If the trial operation fails, feedback error information is provided to trigger the script to be regenerated and iteratively optimized.

[0010] In one embodiment, the raw output stream is converted into a standardized data object; Statistical analysis is performed on the performance index data contained in the standardized data object. The statistical analysis results are then combined with the fault diagnosis rules in the knowledge base to perform logical reasoning on the statistical analysis results, generating targeted operation and maintenance suggestions and providing feedback through the system. According to a second aspect of the present invention, an apparatus for automatically collecting server performance metrics based on a large model of an intelligent agent is provided, comprising: The extraction module is used to receive the operation and maintenance requirement description in natural language form input by the user, perform semantic parsing on the operation and maintenance requirement description according to the preset large language model, extract the identity information of the target server, the type of performance indicator to be collected, and the time parameters of the collection task, and generate a structured collection instruction containing the type of performance indicator to be collected and the time parameters accordingly. The filling module is used to retrieve a matching basic script template from the connected knowledge base based on the type of performance indicator to be collected according to the structured collection instruction, obtain the corresponding operating system environment configuration parameters according to the identity information of the target server, and instantiate and fill the basic script template with the operating system environment configuration parameters to dynamically generate an executable automation script adapted to the target server. The capture module is used to establish a connection session with the target server through a remote secure communication protocol, distribute the executable automation script to the runtime environment of the target server for execution, and capture the raw output stream generated by the script execution in real time.

[0011] According to a third aspect of the present invention, an electronic device is provided, comprising: a communication interface, a processor, and a memory; The memory is used to store program instructions, which, when executed by the processor that is connected to the memory via the communication interface, implement any of the above-described methods for automatically collecting server performance indicators based on a large model intelligent agent.

[0012] According to a fourth aspect of the present invention, a computer-readable storage medium is provided, on which computer program instructions are stored, which, when executed by a computer (e.g., a processor in the computer), implement any of the above-described methods for automatically collecting server performance indicators based on a large model intelligent agent.

[0013] In summary, this invention provides a method for automatically collecting server performance metrics using an intelligent agent based on a large model. The method includes: receiving a user-inputted operation and maintenance requirement description in natural language form; performing semantic parsing on the operation and maintenance requirement description according to a pre-set large language model to extract the target server's identity information, the type of performance metric to be collected, and the time parameters of the collection task; generating a structured collection instruction containing the type of performance metric to be collected and the time parameters; retrieving a matching basic script template from a connected knowledge base based on the type of performance metric to be collected according to the structured collection instruction; obtaining the corresponding operating system environment configuration parameters based on the target server's identity information; instantiating and populating the basic script template using the operating system environment configuration parameters to dynamically generate an executable automated script adapted to the target server; establishing a connection session with the target server through a remote secure communication protocol; sending the executable automated script to the target server's runtime environment for execution; and capturing the raw output stream generated by the script execution in real time. The technical solution of this application realizes intelligent parsing of natural language requirements into structured instructions through a large language model, dynamically generating automated scripts adapted to the target server environment, thus reducing the technical threshold for operation and maintenance; it constructs an automated closed loop from instruction parsing, script generation to execution feedback, improving the efficiency of performance indicator collection; and it combines a knowledge base with real-time data analysis capabilities to realize intelligent fault diagnosis and proactive push of operation and maintenance suggestions, enhancing the intelligence level and accuracy of server operation and maintenance.

[0014] Other features and advantages of the invention will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the invention. The objects and other advantages of the invention may be realized and obtained by means of the structures particularly pointed out in the written description and drawings.

[0015] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings and embodiments. Attached Figure Description

[0016] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0017] Figure 1 A flowchart illustrating a method for automatically collecting server performance metrics by an intelligent agent based on a large model, provided as an embodiment of the present invention; Figure 2 A flowchart illustrating another method for automatically collecting server performance metrics by an intelligent agent based on a large model, provided as an embodiment of the present invention; Figure 3 A flowchart illustrating another method for automatically collecting server performance metrics by an intelligent agent based on a large model, provided as an embodiment of the present invention; Figure 4 A flowchart illustrating another method for automatically collecting server performance metrics by an intelligent agent based on a large model, provided as an embodiment of the present invention; Figure 5 A flowchart illustrating another method for automatically collecting server performance metrics by an intelligent agent based on a large model, provided as an embodiment of the present invention; Figure 6 A flowchart illustrating another method for automatically collecting server performance metrics by an intelligent agent based on a large model, provided as an embodiment of the present invention; Figure 7 A block diagram of a device for automatically collecting server performance indicators based on a large model, provided for embodiments of the present invention; Figure 8 A structural diagram of an electronic device provided as an embodiment of the present invention; Figure 9 A schematic diagram of the structure of a system for automatically collecting server performance indicators based on a large model, provided for an embodiment of the present invention; Figure 10 This is a schematic diagram of a method for automatically collecting server performance indicators based on a large model, provided as an embodiment of the present invention. Detailed Implementation

[0018] The features and exemplary embodiments of various aspects of this application will be described in detail below. To make the objectives, technical solutions, and advantages of this application clearer, the application will be further described in detail below with reference to the accompanying drawings and specific embodiments. It should be understood that the specific embodiments described herein are only intended to explain this application and not to limit it. For those skilled in the art, this application can be implemented without some of these specific details. The following description of the embodiments is merely to provide a better understanding of this application by illustrating examples.

[0019] It should be noted that, in this document, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, 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. Without further limitations, an element defined by the phrase "comprising..." does not exclude the presence of additional identical elements in the process, method, article, or apparatus that includes said element.

[0020] like Figure 1 As shown, this invention provides a method for automatically collecting server performance metrics using an intelligent agent based on a large model. This method includes: In step S11, the system receives a description of operation and maintenance requirements in natural language input from the user, performs semantic parsing on the description of operation and maintenance requirements according to a preset large language model, extracts the identity information of the target server, the type of performance indicators to be collected, and the time parameters of the collection task, and generates a structured collection instruction containing the type of performance indicators to be collected and the time parameters accordingly. In step S12, according to the structured acquisition instruction, a matching basic script template is retrieved from the connected knowledge base based on the type of performance indicator to be acquired, and the corresponding operating system environment configuration parameters are obtained according to the identity information of the target server. The basic script template is instantiated and populated using the operating system environment configuration parameters to dynamically generate an executable automated script adapted to the target server. In step S13, a connection session with the target server is established through a remote secure communication protocol, and the executable automation script is sent to the runtime environment of the target server for execution, capturing the raw output stream generated by the script execution in real time.

[0021] In one embodiment, a data collection agent integrating a large language model and automation technology is deployed. This agent achieves a fully automated end-to-end closed loop from natural language requirement understanding to operation and maintenance suggestion generation through modular collaboration. The data collection agent mainly includes a user interaction module, a large model module, a script execution module, and a data analysis module.

[0022] The user interaction module initiates the human-computer dialogue process. Maintenance personnel do not need to write any scripts or be familiar with complex commands; they only need to describe their maintenance needs in natural language. For example, a user could enter: "Please check the CPU and memory usage per minute for the CentOS 7 server with IP address 192.168.1.105 over the next hour. If any anomalies are found, please inform me." Upon receiving this natural language text, the user interaction module invokes a pre-built large language model for semantic parsing. Leveraging its powerful natural language understanding capabilities, the large language model accurately extracts key elements from the description: the target server's identification information (IP address: 192.168.1.105, operating system type: CentOS 7), the types of performance metrics to be collected (CPU usage, memory usage), and the time parameters of the collection task (duration: 1 hour, collection frequency: per minute). Based on this extracted structured information, the user interaction module generates a clear, structured collection instruction, in a format such as a JSON object. {"target_server": "192.168.1.105 (CentOS 7)", "metrics": ["cpu_usage", "memory_usage"], "duration": "1h", "interval": "1m"} Structured data collection commands are passed to the large model module for dynamic script generation. Upon receiving the commands, the large model module retrieves them from its connected knowledge base based on the "metrics" field (performance metric type). The knowledge base pre-stores basic script templates for various metrics; for example, "cpu_usage" might be associated with a basic Bash script template calculated from the ` / proc / stat` file, while "memory_usage" might be associated with a template parsing the output of the `free` command. Based on the identity information in "target_server," the large model module queries the Configuration Management Database (CMDB) or a similar repository for the server's specific operating system environment configuration parameters, such as the exact path to the Bash interpreter, the installation location of specific toolkits, and necessary environment variables. The large model module acts as an intelligent script compiler, fusing and instantiating the retrieved basic script templates with the obtained environment configuration parameters to generate an environment-adapted executable automated script. This executable automated script not only includes the data collection logic but also typically includes built-in data formatting commands to ensure the regularity of the output results.

[0023] The script execution module is responsible for securely and reliably executing the generated executable automation scripts on the target server. This module establishes an encrypted connection with the target server (i.e., 192.168.1.105) via secure remote communication protocols such as SSH (Secure Shell). After successful authentication, the script execution module transfers the dynamically generated script file from the preceding steps to a temporary directory or memory on the target server for execution. The module monitors and captures the standard output (stdout) and standard error (stderr) streams generated during script execution in real time. To avoid confusion in subsequent processing, the module first discards or records debugging or error information unrelated to performance metrics, performs preliminary cleaning and transformation on the clean raw output stream (e.g., text format "CPU: 15.2%, Mem: 67.8%), encapsulates it into a standardized data object (e.g., a JSON object containing a timestamp, server ID, metric name, and metric value), and then transmits it to the data analysis module.

[0024] The data analysis module performs in-depth processing on the received standardized data objects. This module can perform preliminary statistical analysis. For example, it calculates the average and peak CPU usage over a specified time period and determines whether it consistently exceeds a preset safety threshold (e.g., 90%); or analyzes the growth trend of memory usage. These statistical analysis results are organized into a concise data report, which is then fed back to the large model module.

[0025] After receiving the statistical report from the data analysis module, the large model module combines it with predefined fault diagnosis rules and domain knowledge in the knowledge base to perform logical reasoning. For example, a rule might indicate that "if CPU utilization consistently exceeds 80% and memory utilization remains high, there may be resource contention or memory leaks." The large model module applies such rules to analyze the current data. If it finds that the average CPU utilization has reached 92% for 10 minutes, it will infer that "the target server is experiencing high CPU load, posing a performance bottleneck risk," and generate targeted operation and maintenance recommendations accordingly. For example, Recommendation 1: Use the `top` command to further check the process consuming the most CPU; Recommendation 2: Consider optimizing the configuration of currently running applications or expanding resource capacity. The generated operation and maintenance plan, containing problem diagnosis and action suggestions, is then fed back to the operation and maintenance personnel who initially submitted the request in a clear and user-friendly manner through the user interaction module.

[0026] This embodiment constructs a complete automated closed loop from requirement input to operation and maintenance suggestion feedback through the coordinated operation of various modules. The core components of the system include a user interaction module, a large model module, a script execution module, a data analysis module, and a knowledge base module. Each module has a clearly defined function and achieves data interaction through standardized interfaces. A schematic diagram of the system structure for automatically collecting server performance indicators based on a large model-based intelligent agent is attached. Figure 9 As shown.

[0027] The user interaction module, acting as the system front-end, receives maintenance requests input by users in natural language and preprocesses the input text before transmitting it to the large model module. The large model module, serving as the intelligent decision-making center, not only performs semantic parsing of user requests to generate structured collection instructions but also dynamically generates executable automated scripts adapted to the target server based on script templates and environmental parameters in the knowledge base. Simultaneously, this module is also responsible for intelligently reasoning from the results fed back by the data analysis module to generate final maintenance recommendations.

[0028] The script execution module receives executable automated scripts generated by the large model module and executes them on the target server via remote security protocols such as SSH. It collects performance metric data in real time and converts it into a standardized data format before transmitting it to the data analysis module. The data analysis module then cleans, preprocesses, and statistically analyzes the received performance data, identifying abnormal patterns and trends to provide data support for subsequent intelligent diagnostics.

[0029] The knowledge base module serves as the system's knowledge foundation, storing operational knowledge including script templates, fault diagnosis rules, and performance baselines. It provides continuous knowledge support to other modules through standard API interfaces. Through the close collaboration of these modules, the system achieves full automation of server performance metric collection and analysis, improving operational efficiency and intelligence.

[0030] A schematic diagram of the method for automatically collecting server performance metrics by intelligent agents based on large models is attached. Figure 10 As shown, users input their maintenance requirements in natural language through the user interaction module. This module preprocesses the input text and then calls a pre-built large language model for semantic parsing, accurately extracting key elements such as the target server's identity information, the types of performance metrics to be collected, and the time parameters of the collection task, generating structured collection instructions. The large model module receives these structured instructions, retrieves matching basic script templates from its connected knowledge base based on the performance metric type, and obtains the corresponding operating system environment configuration parameters based on the target server's identity information. By instantiating and populating the basic script template with the environment configuration parameters, it dynamically generates an executable automation script fully adapted to the target server. During the generation process, the module performs checks on syntax, environment compatibility, and security. If checks fail, it iteratively optimizes the script based on the error messages until a compliant executable script is generated. The script execution module is responsible for establishing a secure connection with the target server and deploying the generated executable automation script to the target server environment for execution. This script execution module captures the raw output stream generated by the script execution in real time and converts it into standardized data objects. To ensure reliable execution, the module implements comprehensive monitoring and status management, including process hosting, heartbeat detection, log auditing, and resource control, and possesses fault tolerance and maintenance mechanisms such as data caching, transmission retry, abnormal restart, and version rollback. After receiving standardized data objects, the data analysis module cleans, preprocesses, and statistically analyzes the performance indicator data contained within, calculating statistics and identifying trends. The analysis results are fed back to the large model module, which combines historical baseline data from the knowledge base with fault diagnosis rules to perform logical reasoning, achieving anomaly detection and problem localization. Based on the analysis results and knowledge base information, the large model module generates targeted operation and maintenance suggestions and provides the complete analysis conclusions and suggestions to the user through the user interaction module. Simultaneously, the relevant data collected and analyzed is stored in the knowledge base, thereby enabling the continuous self-evolution of the data collection agent.

[0031] The technical solution in this embodiment achieves intelligent parsing of natural language requirements into structured instructions through a large language model, dynamically generating automated scripts adapted to the target server environment, thus lowering the technical threshold for operation and maintenance; it constructs an automated closed loop from instruction parsing, script generation to execution feedback, improving the efficiency of performance indicator collection; and combined with a knowledge base and real-time data analysis capabilities, it realizes intelligent fault diagnosis and proactive push of operation and maintenance suggestions, enhancing the intelligence level and accuracy of server operation and maintenance.

[0032] In one embodiment, such as Figure 2 As shown, it also includes the following steps S21-S23: In step S21, the operating system environment configuration parameters are parsed to determine the operating system type and kernel version number of the target server, and compatible system call commands or API interface names are filtered from the instruction set of the knowledge base according to the kernel version number. In step S22, the selected system call commands or API interface names are injected into the reserved function slots of the basic script template to form intermediate script code; In step S23, based on the time parameter in the structured acquisition instruction, loop control logic or timed trigger logic is implanted into the intermediate script code, and syntax integrity is checked. After the check passes, the executable automated script is generated.

[0033] In one embodiment, by parsing the obtained operating system environment configuration parameters, the operating system type (such as CentOS, Ubuntu, Windows Server, etc.) and specific kernel version number (e.g., CentOS 7.9, Ubuntu 22.04 LTS) of the target server are accurately determined. Based on the environment information, the system performs compatibility filtering from a pre-built instruction set in a knowledge base. This knowledge base stores system call commands or API interfaces optimized for different operating systems and kernel versions. For example, for CentOS 7.x series, the yum command is selected for package management, and specific interfaces under / proc / stat are used to collect CPU metrics; while for Ubuntu 22.04, the apt-get command is used accordingly, and a matching performance data collection path is selected. This step ensures that the selected commands and interfaces are available in the target server environment and behave as expected, fundamentally avoiding execution failures caused by missing commands or syntax differences.

[0034] The system injects selected system call commands or API interface names into pre-defined reserved function slots in the basic script template, forming intermediate script code. This basic script template is a framework with complete functional logic but some key elements are yet to be determined; for example, the template might contain a slot marked ${CPU_COLLECTION_COMMAND}. Based on the aforementioned filtering results, the system replaces this slot with a specific command applicable to the target server, such as cpu_usage = $(grep 'cpu ' / proc / stat | awk '{usage=($2+$4)*100 / ($2+$4+$5)} END {print usage}') in a CentOS environment. After filling all function slots, the system injects corresponding control logic into the intermediate script code based on the time parameters (such as sampling frequency and duration) in the structured acquisition instructions. For periodic acquisition tasks, it generates crontab expressions or logic combining while loops with sleep instructions; for one-time tasks, it may set specific execution times or delay trigger mechanisms.

[0035] Before generating an executable automation script, the system performs a rigorous syntax integrity check on the intermediate script code, which contains specific commands and control logic. The check utilizes corresponding syntax rules from a knowledge base (e.g., shellcheck for shell scripts, pyflakes for Python scripts) for static analysis to check for syntax errors, undefined variables, or potential security risks. Only after the check passes completely is the system considered a safe executable automation script for deployment to the target server. If the check fails, the system automatically backtracks to previous steps based on the error message to adjust parameters or re-select commands until a syntactically correct and logically complete final script is generated.

[0036] In one embodiment, such as Figure 3 As shown, it also includes the following steps S31-S33: In step S31, the script execution module queries the asset management list based on the identity information of the target server, obtains the corresponding IP address, port number and access credentials, and initiates a connection request for the SSH encrypted channel or WinRM remote management channel accordingly. In step S32, after the connection session is successfully established, the executable automation script is transferred to the temporary working directory of the target server through the connection session, and the executable automation script is granted execution permissions in the operating system environment. In step S33, an execution command is sent to trigger the execution of the executable automated script, and the connection session remains active until a signal indicating the end of script execution is received. Subsequently, a cleanup command is sent to delete the script file in the temporary working directory and disconnect the connection.

[0037] In one embodiment, the script execution module first queries a pre-configured asset management list based on the target server identification information (e.g., server hostname or asset number) parsed from the structured acquisition instructions. This pre-configured asset management list maintains the network configuration and authentication information of all servers within the enterprise, including but not limited to IP addresses, SSH / WinRM service port numbers, and corresponding access credentials (e.g., SSH private key paths or Windows domain account credentials). Based on the obtained connection parameters, the script execution module initiates an encrypted channel connection request based on the SSH 2.0 protocol for Linux servers, or a remote management connection based on the WinRM (WS-Management) protocol for Windows servers. During the connection establishment process, the script execution module implements strict host key verification and certificate verification, and supports network relay via jump servers to ensure network security and compliance during the connection process.

[0038] After a successful connection session, the script execution module uses the encrypted channel to transfer the generated executable automation script file to a pre-defined temporary working directory on the target server's operating system, such as the ` / tmp` directory on Linux or the `%TEMP%` directory on Windows. Once the transfer is complete, the script execution module remotely executes a permission modification command (e.g., `chmod + x / tmp / script_name.sh` on Linux, or the `Unblock-File` command in PowerShell on Windows) to grant the script file execute permissions within the current operating system environment. The script execution module then sends an execution command through the session channel to trigger script execution. For Linux environments, this is typically initiated using the `bash / tmp / script_name.sh` command; for Windows environments, it's initiated using the `PowerShell -File C:\Temp\script_name.ps1` command.

[0039] Throughout the script execution, the script execution module keeps the remote connection session active and monitors the session's output stream (stdout) and error stream (stderr) in real time to capture the script's real-time status and preliminary results. The script execution module maintains this state until it receives an exit signal indicating the script process has finished running. Once the script execution is confirmed complete, regardless of success or failure, the script execution module sends a cleanup command to remotely delete the script file temporarily stored in the target server's temporary working directory, thereby eliminating potential security risks and freeing up storage space. The script execution module actively closes the remote connection session, completing a full script distribution, execution, and cleanup process, and records the execution's metadata (such as start time, end time, and exit code) for auditing and analysis.

[0040] In one embodiment, such as Figure 4 As shown, it also includes the following steps S41-S43: In step S41, the original output stream is intercepted by character stream. Noise data containing system prompts, newline characters and non-ASCII encoded characters is filtered out by a preset regular expression library, and effective performance index values ​​are extracted. In step S42, according to the key-value mapping rules corresponding to the performance indicator type, the extracted performance indicator values ​​are associated with the collection timestamp and server ID to construct a structured data packet that conforms to the JSON specification. In step S43, the structured data packet is validated for field types. If the validation passes, the structured data packet is pushed to the input buffer of the data analysis module via a message queue or HTTP interface.

[0041] In one embodiment, after the script execution module executes an automated script on the target server and captures its raw output stream in real time, it initiates a data cleaning process. The script execution module intercepts and buffers the captured character stream in real time and calls a pre-built regular expression library to parse the raw data line by line. The regular expression library defines matching patterns for different performance metric output formats, effectively identifying and filtering noisy data such as system prompts (e.g., command line prompts [root@host~]#), irrelevant newline characters, control characters, and non-ASCII encoded characters. For example, for the output of the vmstat command, the regular expression \s+(\d+) can accurately extract the numerical data of each field, ensuring that only purely valid performance metric values ​​are retained.

[0042] After successfully extracting valid values, the script execution module calls a preset key-value mapping rule from the knowledge base based on the performance metric type corresponding to the current data collection task. This key-value mapping rule explicitly defines the performance metric name (e.g., "cpu_usage"), unit, and data format represented by each value. The script execution module associates the extracted performance metric values ​​with the timestamp of the data collection time and the unique identifier of the target server, constructing a structured data packet conforming to the JSON specification. For example, a complete data packet might look like this: {"server_id": "SVR_192.168.1.105", "timestamp": "2023-10-01T12:00:00Z", "metrics": {"cpu_usage":45.2, "memory_usage": 78.1}}, ensuring that heterogeneous data from different operating systems and different data collection commands have a unified data model.

[0043] After the data packet is assembled, the script execution module performs rigorous field type validation to verify that the values ​​are within a reasonable range (e.g., whether the CPU utilization is a floating-point number between 0 and 100), that required fields are complete, and that the JSON format is correct. If the validation passes, the script execution module pushes the standardized structured data packet to the input buffer of the data analysis module via an asynchronous message queue (such as Kafka or RabbitMQ) or a synchronous HTTP RESTful interface. If the validation fails, the data packet will be marked as abnormal and transferred to the error handling process, while triggering an alarm to notify the operations and maintenance personnel to intervene.

[0044] In one embodiment, such as Figure 5 As shown, it also includes the following steps S51-S53: In step S51, the user interaction module collects user feedback data on the operation and maintenance suggestion plan. The feedback data includes validity markers and the user's revised suggestion content. In step S52, the large model module extracts features from the evaluation feedback data. If the validity is marked as positive, the executable automated script and the corresponding fault diagnosis rule generated this time are extracted as positive samples. In step S53, the script template weights and fault feature vectors in the knowledge base are updated and adjusted using the positive samples, so that the processing logic corresponding to the positive samples is given priority when the same type of operation and maintenance requirement description is received in the future.

[0045] In one embodiment, after the maintenance suggestion is fed back to the user through the user interaction module, the system actively collects user feedback data on the suggestion. This feedback data is recorded in a structured format, containing two core elements: a binary label indicating the user's assessment of the suggestion's validity (e.g., "adopted / valid" or "not adopted / invalid"), and possible corrections or supplementary explanations made by the user during actual operation. The user interaction module packages this feedback data along with the corresponding original maintenance requirements, generated scripts, and suggested solutions to form a complete feedback record, which is then transmitted to the large model module for further processing. The large model module receives and parses the feedback record. When a "positive" validity label is identified in the feedback data, the system marks the executable automated script generated and successfully executed in this interaction, the script template used, and the fault diagnosis rules and feature data that triggered the generation of the maintenance suggestion as a positive sample. For example, a specific troubleshooting script generated for the "high CPU utilization" problem and confirmed as valid by the user, along with its associated diagnostic rules, will be extracted as a success case.

[0046] The system uses these proven positive samples to perform targeted optimization of the knowledge base. Specifically, the system increases the weight or priority of the basic script template corresponding to the positive sample in the knowledge base, and uses its contained success features to fine-tune and enhance the feature vectors in the relevant fault diagnosis rules. When the system subsequently receives semantically similar or server-environment-similar operation and maintenance requirement descriptions, the large model module can prioritize retrieving and recommending proven and effective script templates and diagnostic logic based on the updated knowledge base, thereby achieving continuous iteration of the system's operation and maintenance capabilities and continuous improvement of its intelligence level.

[0047] In one embodiment, such as Figure 6 As shown, it also includes the following steps S61-S63: In step S61, based on the programming language type of the generated automated script, the corresponding static code analysis tool is called to perform syntax checking. Specifically, if the script is in Python, the pyflakes tool is called to perform the check; if the script is in Shell, the shellcheck tool is called to perform the check, and syntax errors are automatically corrected based on the check results. In step S62, the automated script is scanned. If a high-risk system call instruction is found, the script process is blocked or a second confirmation is performed. If hard-coded key information is found, it is automatically replaced with an environment variable reference. In step S63, a containerized simulation environment consistent with the target server operating system version is constructed. The automation script is deployed to this containerized simulation environment for trial operation to verify the validity of the system commands called in the script and the path of the performance indicator file read in the target environment. If the trial operation fails, error information is fed back to the large model module to trigger the regeneration and iterative optimization of the script.

[0048] In one embodiment, after the large model module dynamically generates executable automated scripts, a corresponding static code analysis tool is invoked to perform rigorous syntax checks based on the script's programming language. Specifically, if the generated script is in Python, the pyflakes tool is invoked to analyze its syntax and simple logic errors; if it is in Shell, the shellcheck tool is invoked. Syntax errors identified by the analysis tools, such as undefined variables, mismatched quotation marks, or incorrect syntax formatting, are automatically corrected by the system according to a pre-defined set of correction rules, such as adding missing statement terminators or correcting incorrect indentation.

[0049] After completing the syntax check, the system performs a security scan on the script content, identifying and handling two types of potential risks. First, high-risk system call commands, such as `rm -rf / ` and `format`, which could cause irreversible damage to the system. Upon detecting such commands, the system will automatically block the script flow and generate an alert. Second, hard-coded sensitive information, such as passwords and API keys. The system will automatically identify these plaintext credentials and replace them with environment variable references obtained from the security key management system (for example, replacing the hard-coded password "123456" with `${DB_PASSWORD}`), thereby improving the security of script execution.

[0050] To verify the script's compatibility in a real environment, a containerized simulation environment identical to the target server's operating system version is built (e.g., using Docker to start a CentOS 7.9 container instance). The automation script is deployed to this environment for trial runs to verify the existence of the system commands it calls (such as iostat and Get-Counter) and the accessibility of the performance metric file paths it needs to read (such as / proc / meminfo). If the trial run fails, the container environment captures specific error messages (such as "command not found" or "file not found") and reports them to the large model module. The large model module iteratively optimizes based on these error messages. For example, it adds prerequisite dependency installation commands to the script or corrects file paths, and repeats the above verification process until a robust script fully adapted to the target environment is generated.

[0051] In one embodiment, Figure 7This is a block diagram illustrating an apparatus for automatically collecting server performance metrics based on a large model, according to an exemplary embodiment. Figure 7 As shown, the device for automatically collecting server performance indicators based on a large model intelligent agent includes an extraction module 71, a filling module 72, a capture module 73, and an inference module 74.

[0052] The extraction module 71 is used by the user interaction module to receive the operation and maintenance requirement description in natural language form input by the user, perform semantic parsing on the operation and maintenance requirement description according to the preset large language model, extract the identity information of the target server, the type of performance indicator to be collected, and the time parameters of the collection task, and generate a structured collection instruction containing the type of performance indicator to be collected and the time parameters accordingly. The filling module 72 is used to retrieve a matching basic script template in the connected knowledge base based on the type of performance indicator to be collected according to the structured collection instruction, obtain the corresponding operating system environment configuration parameters according to the identity information of the target server, and instantiate and fill the basic script template through the operating system environment configuration parameters to dynamically generate an executable automated script adapted to the target server. The capture module 73 is used to establish a connection session with the target server through a remote secure communication protocol, send the executable automation script to the runtime environment of the target server for execution, capture the raw output stream generated by the script execution in real time, and convert the raw output stream into a standardized data object for transmission to the data analysis module; The reasoning module 74 is used by the data analysis module to receive the standardized data object, perform statistical analysis on the performance index data contained in the standardized data object, and feed back the statistical analysis results to the large model module. The large model module combines the fault diagnosis rules in the knowledge base to perform logical reasoning on the statistical analysis results, generate targeted operation and maintenance suggestion solutions, and feed them back through the user interaction module.

[0053] The extraction module 71, the filling module 72, the capture module 73, and the inference module 74 included in the block diagram of the device for automatically collecting server performance indicators based on a large model are controlled to execute the method for automatically collecting server performance indicators based on a large model as described in any of the above embodiments.

[0054] like Figure 8 As shown, the present invention provides an electronic device 800, which includes: a communication interface, a processor 801, and a memory 802; The memory 802 stores program instructions. When the program instructions are executed by the processor 801, which is connected to the memory 802 via the communication interface, the user interaction module receives a natural language description of the operation and maintenance requirements input by the user. Based on a preset large language model, the module performs semantic parsing on the operation and maintenance requirements description to extract the target server's identity information, the type of performance indicators to be collected, and the time parameters of the collection task. Based on this, a structured collection instruction containing the type of performance indicators to be collected and the time parameters is generated. According to the structured collection instruction, a matching basic script template is retrieved from the connected knowledge base based on the type of performance indicators to be collected. The corresponding operating system environment configuration parameters are obtained based on the target server's identity information. The basic script template is instantiated and populated using the operating system environment configuration parameters to dynamically generate an executable automated script adapted to the target server. A connection session with the target server is established through a remote secure communication protocol, and the executable automated script is sent to the target server's runtime environment for execution, capturing the raw output stream generated by the script execution in real time.

[0055] This invention provides a computer-readable storage medium storing computer program instructions. When the computer program instructions are executed by a processor, a user interaction module receives a user-inputted maintenance requirement description in natural language. Based on a pre-set large language model, the module performs semantic parsing on the maintenance requirement description to extract the target server's identity information, the type of performance indicator to be collected, and the time parameters of the collection task. Based on this, a structured collection instruction containing the performance indicator type and time parameters is generated. According to the structured collection instruction, a matching basic script template is retrieved from a connected knowledge base based on the performance indicator type to be collected. The corresponding operating system environment configuration parameters are obtained based on the target server's identity information. The basic script template is instantiated and populated using the operating system environment configuration parameters to dynamically generate an executable automated script adapted to the target server. A connection is established with the target server via a remote secure communication protocol, and the executable automated script is sent to the target server's runtime environment for execution, capturing the raw output stream generated by the script execution in real time.

[0056] It should be understood that the specific features, operations, and details described above regarding the method of the present invention can also be similarly applied to the apparatus and system of the present invention, or vice versa. Furthermore, each step of the method of the present invention described above can be performed by a corresponding component or unit of the apparatus or system of the present invention.

[0057] It should be understood that the various modules / units of the device of the present invention can be implemented wholly or partially through software, hardware, firmware, or a combination thereof. Each module / unit can be embedded in the processor of a computer device in hardware or firmware form or independent of the processor, or it can be stored in the memory of a computer device in software form for the processor to call to execute the operation of each module / unit. Each module / unit can be implemented as an independent component or module, or two or more modules / units can be implemented as a single component or module.

[0058] In one embodiment, a computer device is provided, including a memory and a processor. The memory stores computer instructions executable by the processor, which, when executed by the processor, instruct the processor to perform steps of the methods of embodiments of the present invention. The computer device can be broadly categorized as a server, terminal, or any other electronic device with the necessary computing and / or processing capabilities. In one embodiment, the computer device may include a processor, memory, network interface, communication interface, etc., connected via a system bus. The processor of the computer device can be used to provide the necessary computing, processing, and / or control capabilities. The memory of the computer device may include a non-volatile storage medium and internal memory. The non-volatile storage medium may store an operating system, computer programs, etc. The internal memory can provide an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The network interface and communication interface of the computer device can be used to connect and communicate with external devices via a network. When the computer program is executed by the processor, it performs the steps of the methods of the present invention.

[0059] This invention can be implemented as a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, causes the steps of the methods of embodiments of the invention to be performed. In one embodiment, the computer program is distributed across multiple network-coupled computer devices or processors, such that the computer program is stored, accessed, and executed in a distributed manner by one or more computer devices or processors. A single method step / operation, or two or more method steps / operations, may be executed by a single computer device or processor or by two or more computer devices or processors. One or more method steps / operations may be executed by one or more computer devices or processors, and one or more other method steps / operations may be executed by one or more other computer devices or processors. One or more computer devices or processors may execute a single method step / operation, or execute two or more method steps / operations.

[0060] It will be understood by those skilled in the art that the method steps of the present invention can be performed by a computer program instructing related hardware, such as a computer device or processor. The computer program may be stored in a non-transitory computer-readable storage medium, and its execution causes the steps of the present invention to be performed. Depending on the context, any references herein to memory, storage, databases, or other media may include non-volatile and / or volatile memory. Examples of non-volatile memory include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), flash memory, magnetic tape, floppy disk, magneto-optical data storage device, optical data storage device, hard disk, solid-state drive, etc. Examples of volatile memory include random access memory (RAM), external cache memory, etc.

[0061] The technical features described above can be combined arbitrarily. Although not all possible combinations of these technical features are described, any combination of these technical features should be considered to be covered by this specification, provided that such combination does not contain contradictions.

[0062] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for automatically collecting server performance indicators based on a large model-based intelligent agent, characterized in that, Applications include data collection agents based on large models combined with automated scripts, including: The system receives a description of operation and maintenance requirements in natural language input from the user, performs semantic parsing on the description of operation and maintenance requirements based on a pre-set large language model, extracts the identity information of the target server, the type of performance indicators to be collected, and the time parameters of the collection task, and generates a structured collection instruction containing the type of performance indicators to be collected and the time parameters accordingly. According to the structured collection instructions, a matching basic script template is retrieved from the connected knowledge base based on the type of performance indicator to be collected, and the corresponding operating system environment configuration parameters are obtained according to the identity information of the target server. The basic script template is instantiated and populated using the operating system environment configuration parameters to dynamically generate an executable automation script adapted to the target server. A connection session with the target server is established through a remote secure communication protocol, and the executable automation script is sent to the runtime environment of the target server for execution, capturing the raw output stream generated by the script execution in real time.

2. The method for automatically collecting server performance indicators based on a large model of intelligent agents as described in claim 1, characterized in that, The step of instantiating and populating the basic script template using the operating system environment configuration parameters to dynamically generate an executable automation script adapted to the target server includes: The operating system environment configuration parameters are parsed to determine the operating system type and kernel version number of the target server, and compatible system call commands or API interface names are filtered from the instruction set of the knowledge base based on the kernel version number; The selected system call commands or API interface names are injected into the reserved function slots of the basic script template to form intermediate script code; Based on the time parameters in the structured acquisition instructions, loop control logic or timed triggering logic is implanted into the intermediate script code, and syntax integrity is checked. After the check passes, the executable automated script is generated.

3. The method for automatically collecting server performance indicators based on a large model of intelligent agents as described in claim 1, characterized in that, The step of establishing a connection session with the target server via a remote secure communication protocol and distributing the executable automation script to the target server's runtime environment for execution includes: Based on the identity information of the target server, query the asset management list to obtain the corresponding IP address, port number and access credentials, and initiate a connection request for an SSH encrypted channel or WinRM remote management channel accordingly. After the connection session is successfully established, the executable automation script is transferred to the temporary working directory of the target server through the connection session, and the executable automation script is granted execution permissions in the operating system environment. An execution command is sent to trigger the execution of the executable automated script, and the connection session remains active until a signal indicating the end of script execution is received. Subsequently, a cleanup command is sent to delete the script file in the temporary working directory and disconnect the connection.

4. The method for automatically collecting server performance indicators based on a large model of intelligent agents as described in claim 1, characterized in that, The process of converting the original output stream into a standardized data object includes: The original output stream is intercepted by character stream, and noise data containing system prompts, newline characters and non-ASCII encoded characters is filtered out by a preset regular expression library to extract effective performance index values. Based on the key-value mapping rules corresponding to the performance metric type, the extracted performance metric values ​​are associated with the collection timestamp and server ID to construct a structured data packet that conforms to the JSON specification. The structured data packet is validated for field types. If the validation passes, the structured data packet is pushed to the input buffer via a message queue or HTTP interface.

5. The method for automatically collecting server performance indicators based on a large model of intelligent agents as described in claim 1, characterized in that, Also includes: Collect user feedback data on the proposed operation and maintenance solution. The feedback data includes validity markers and user-corrected suggestions. The evaluation feedback data is subjected to feature extraction. If the validity is marked as positive, the executable automated script and the corresponding fault diagnosis rule generated this time are extracted as positive samples. The script template weights and fault feature vectors in the knowledge base are updated and adjusted using the positive samples, so that the processing logic corresponding to the positive samples is given priority when the same type of operation and maintenance requirement description is received in the future.

6. The method for automatically collecting server performance indicators based on a large model of intelligent agents as described in claim 1, characterized in that, Also includes: Based on the programming language type of the generated automated script, the corresponding static code analysis tool is called to perform syntax checks. Specifically, if the script is in Python, the pyflakes tool is called for checking, and if the script is in Shell, the shellcheck tool is called for checking. Syntax errors are automatically corrected based on the check results. The automated script is scanned. If a high-risk system call instruction is found, the script process is blocked or a second confirmation is performed. If hard-coded key information is found, it is automatically replaced with an environment variable reference. Construct a containerized simulation environment that matches the target server's operating system version. Deploy the automation script to the containerized simulation environment for trial operation to verify the validity of the system commands called in the script and the paths to the performance indicator files read in the target environment. If the trial operation fails, feedback error information is provided to trigger the script to be regenerated and iteratively optimized.

7. The method for automatically collecting server performance indicators based on a large model of intelligent agents as described in claim 1, characterized in that, Also includes: Convert the raw output stream into a standardized data object; The performance index data contained in the standardized data object are statistically analyzed, and the statistical analysis results are combined with the fault diagnosis rules in the knowledge base to perform logical reasoning on the statistical analysis results, generate targeted operation and maintenance suggestions, and then provide feedback.

8. A device for automatically collecting server performance metrics using an intelligent agent based on a large model, comprising: The extraction module is used to receive the operation and maintenance requirement description in natural language form input by the user, perform semantic parsing on the operation and maintenance requirement description according to the preset large language model, extract the identity information of the target server, the type of performance indicator to be collected, and the time parameters of the collection task, and generate a structured collection instruction containing the type of performance indicator to be collected and the time parameters accordingly. The filling module is used to retrieve a matching basic script template from the connected knowledge base based on the type of performance indicator to be collected according to the structured collection instruction, obtain the corresponding operating system environment configuration parameters according to the identity information of the target server, and instantiate and fill the basic script template with the operating system environment configuration parameters to dynamically generate an executable automation script adapted to the target server. The capture module is used by the script execution module to obtain the executable automation script, establish a connection session with the target server through a remote secure communication protocol, send the executable automation script to the runtime environment of the target server for execution, and capture the raw output stream generated by the script execution in real time.

9. An electronic device, characterized in that, include: Communication interface, processor, memory; The memory is used to store program instructions, which, when executed by the processor that is communicatively connected to the memory via the communication interface, enable the electronic device to implement the method for automatically collecting server performance indicators based on a large model as described in any one of claims 1 to 7.

10. A computer-readable storage medium having program instructions stored thereon, characterized in that, When the program instructions are executed by a computer, the computer implements the method for automatically collecting server performance indicators based on a large model, as described in any one of claims 1 to 7.

Images