Method for generating intelligent agent by intelligent computing cloud platform and related device

Abstract

The application provides a method for generating an intelligent agent by computing power of an intelligent computing cloud platform and related devices, and the method comprises the following steps: S1: after an intelligent agent factory is initialized, an intelligent agent instance is created in the intelligent agent factory; S2: natural language analysis is performed on a text format creation requirement input by a user to determine an ability requirement and whether a basic intelligent agent instance can meet the ability requirement; S3: if the basic intelligent agent instance cannot meet the ability requirement, a tool set is loaded, a plurality of first tools capable of meeting the ability requirement are determined from the tool set, computing power of the intelligent computing cloud platform is called, and all the first tools are assembled to the intelligent agent instance; and S4: if the basic intelligent agent instance can meet the ability requirement, the basic intelligent agent instance is created. In the application, the intelligent agent factory built in the intelligent computing cloud platform can call the computing power of the intelligent computing cloud platform according to natural language of a user to construct an intelligent agent meeting the ability requirement.

Description

Technical Field

[0001] This invention relates to the field of intelligent computing cloud platform and computing infrastructure technology, and in particular to a method and related apparatus for generating intelligent agents through computing power on an intelligent computing cloud platform. Background Technology

[0002] With the rapid development of artificial intelligence technology, the "intelligent computing cloud platform" has emerged.

[0003] "Intelligent computing cloud platform" refers to a cloud computing platform that provides intelligent computing services based on the hardware and software resources of an intelligent computing center.

[0004] "Intelligent computing" refers to computing driven by intelligent computing power (GPU, FPGA, ASIC, etc.), and is a general term for computing theories, methods, architectures, and technical capabilities characterized by data intensity and model-based nature. Its goal is to obtain better results by utilizing specific computing resources and appropriate computing methods according to the needs of the task.

[0005] A "Smart Computing Center" refers to a facility that utilizes large-scale heterogeneous computing resources, including general-purpose computing power (CPU) and intelligent computing power (GPU, FPGA, ASIC, etc.), to provide the necessary computing power, data, and algorithms for artificial intelligence applications (such as the development, training, and inference of deep learning models). A Smart Computing Center encompasses facilities, hardware, and software, and can provide full-stack capabilities from underlying computing power to top-level application enablement.

[0006] "Computing power" is the core of "intelligent computing cloud platform". It is the ability of computer equipment or computing / data center to process information. It is the ability of computer hardware and software to work together to perform a certain computing requirement. It is the computing power to achieve the target output by processing information data. It is a new type of productivity that integrates information computing power, network carrying capacity and data storage capacity. It mainly provides services to society through computing power infrastructure.

[0007] Since the emergence of intelligent computing centers, although there are technical solutions that use external programs to call the computing power of intelligent computing centers to generate intelligent agents, the technical problem that urgently needs to be solved is to build an intelligent agent generation module (intelligent agent factory) into the intelligent computing center and enable the intelligent computing center to generate intelligent agents based on the user's natural language. Summary of the Invention

[0008] This invention provides a method and related apparatus for generating intelligent agents through computing power in an intelligent computing cloud platform, in order to solve the technical problem of building an intelligent agent generation module (intelligent agent factory) in the intelligent computing center and enabling the intelligent computing center to generate intelligent agents based on the user's natural language.

[0009] To solve the above-mentioned technical problems, the present invention is implemented as follows:

[0010] In a first aspect, the present invention provides a method for generating intelligent agents through computing power on an intelligent computing cloud platform, applied to an intelligent agent factory built into the intelligent computing cloud platform, the method comprising:

[0011] Step S1: After the agent factory is initialized, agent instances are created in the agent factory;

[0012] Step S2: Perform natural language parsing on the creation requirements of the text format input by the user to determine the user's ability requirements for autonomously constructing intelligent agents, and determine whether the basic intelligent agent instance can meet the ability requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools;

[0013] Step S3: If the basic intelligent agent instance cannot meet the capability requirements, load the toolset, determine multiple first tools from the toolset that can meet the capability requirements, call the computing power of the intelligent computing cloud platform, and assemble all the first tools into the intelligent agent instance;

[0014] Step S4: If the basic agent instance can meet the capability requirements, create the basic agent instance and use the basic agent instance as the target agent.

[0015] Optionally, step S4 includes:

[0016] Step S41: Create the basic agent instance in the agent factory using the singleton creation method.

[0017] Optionally, step S41 includes:

[0018] Step S411: Obtain the creation request sent by the user through the interactive terminal to create the basic intelligent agent instance;

[0019] Step S412: Parse the creation request to obtain the agent identifier of the basic agent instance that the user requests to create, and obtain the context information describing the capabilities of the basic agent instance; determine the basic tool from the preset basic tool set based on the agent identifier and the context information;

[0020] Step S413: Assemble the basic tools into the agent instance to obtain the basic agent instance.

[0021] Optionally, step S3 includes:

[0022] Step S31: Arrange the first tools according to the dependencies between them; the dependencies represent the execution order of the first tools during the execution process and the calling relationship between the first tools.

[0023] Step S32: According to the arrangement result, assemble all the first tools into the agent instance.

[0024] Optionally, step S3 is followed by:

[0025] Step S5: Using the agent instance that has completed the integration of the first tool as the first agent instance, perform tool repeatability detection on the first agent instance to obtain the detection result;

[0026] Step S6: If the detection result indicates that the first agent instance has duplicate tools, perform tool deduplication processing on the first agent instance to obtain the target agent.

[0027] Optionally, step S6 is followed by:

[0028] Step S7: Cache the target intelligent agent to the pre-allocated storage space on the intelligent computing cloud platform, and generate a unique cache key representing the target intelligent agent cached in the storage space.

[0029] Secondly, embodiments of the present invention provide a device for generating intelligent agents through computing power in an intelligent computing cloud platform, applied to an intelligent agent factory built into the intelligent computing cloud platform, the device comprising:

[0030] A creation module is used to create agent instances in the agent factory after the agent factory is initialized.

[0031] The confirmation module is used to perform natural language parsing on the creation requirements of the text format input by the user, determine the user's ability requirements for autonomously constructing intelligent agents, and determine whether the basic intelligent agent instance can meet the ability requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools;

[0032] The first execution module is configured to, if the basic intelligent agent instance cannot meet the capability requirements, load a toolset, determine multiple first tools from the toolset that can meet the capability requirements, call the computing power of the intelligent computing cloud platform, and assemble all the first tools into the intelligent agent instance;

[0033] The second execution module is used to create the basic intelligent agent instance if the basic intelligent agent instance can meet the capability requirements, and use the basic intelligent agent instance as the target intelligent agent.

[0034] Thirdly, embodiments of the present invention provide an electronic device, including a processor, a memory, and a program or instructions stored in the memory and executable on the processor, wherein when the program or instructions are executed by the processor, they implement the steps in the method of generating an intelligent agent by computing power in the intelligent computing cloud platform as described in any one of the first aspects.

[0035] Fourthly, embodiments of the present invention provide a readable storage medium storing a program or instructions, which, when executed by a processor, implement the steps in the method for generating intelligent agents through computing power by an intelligent computing cloud platform as described in any one of the first aspects.

[0036] Fifthly, embodiments of the present invention provide a computer program product, including computer instructions, which, when executed by a processor, implement the steps of the method for generating intelligent agents through computing power by an intelligent computing cloud platform as described in any one of the first aspects.

[0037] In this invention, the intelligent agent factory built into the intelligent computing cloud platform executes the following steps: Step S1: After initialization, intelligent agent instances are created within the intelligent agent factory; Step S2: Natural language parsing is performed on the user-inputted text format creation requirements to determine the user's capability requirements for autonomously constructing intelligent agents, and whether the basic intelligent agent instance can meet these requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools; Step S3: If the basic intelligent agent instance cannot meet the capability requirements, a toolset is loaded, and multiple first tools that can meet the capability requirements are determined from the toolset. The computing power of the intelligent computing cloud platform is then invoked to assemble all the first tools into the intelligent agent instance; Step S4: If the basic intelligent agent instance can meet the capability requirements, the basic intelligent agent instance is created, and this basic intelligent agent instance is used as the target intelligent agent. In this invention, the intelligent agent factory built into the intelligent computing cloud platform can invoke the computing power of the intelligent computing cloud platform based on the user's natural language to construct intelligent agents that meet the capability requirements. Attached Figure Description

[0038] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the invention. Furthermore, the same reference numerals denote the same parts throughout the drawings. In the drawings:

[0039] Figure 1 This is a flowchart illustrating the method of generating intelligent agents through computing power in the intelligent computing cloud platform of the present invention.

[0040] Figure 2 A block diagram illustrating the principle of an automatic generation system for intelligent agents;

[0041] Figure 3 A flowchart illustrating the factory initialization and component assembly process;

[0042] Figure 4 A flowchart illustrating the dynamic construction and configuration of intelligent agents;

[0043] Figure 5 A flowchart illustrating the dynamic integration of multiple tool types;

[0044] Figure 6 A flowchart illustrating the unified integration and optimization of multiple tool types;

[0045] Figure 7 A schematic diagram of the adaptive detection and agent assembly process for model providers;

[0046] Figure 8 A flowchart illustrating the process of agent instance cache management and performance optimization;

[0047] Figure 9 This is a schematic diagram of the device for generating intelligent agents through computing power in the intelligent computing cloud platform of the present invention.

[0048] Figure 10 This is a schematic block diagram of the electronic device of the present invention. Detailed Implementation

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

[0050] The terms "first," "second," etc., used in this invention are used to distinguish similar objects, not to describe a specific order or sequence. It should be understood that such terms can be used interchangeably where appropriate so that the invention can be implemented in orders other than those illustrated or described herein, and the objects distinguished by "first" and "second" are generally of the same class, not limited in number; for example, the first object can be one or more. Furthermore, the "or" in this invention indicates at least one of the connected objects. For example, "A or B" covers three scenarios: Scenario 1: including A but not B; Scenario 2: including B but not A; Scenario 3: including both A and B. The character " / " generally indicates that the preceding and following objects are in an "or" relationship.

[0051] Furthermore, the technical features involved in the different embodiments of the present invention described below can be combined with each other as long as they do not conflict with each other.

[0052] The technical terms involved in this invention will be briefly explained below.

[0053] The “computing power” mentioned in this invention refers to: the ability of computer equipment or computing / data center to process information; the ability of computer hardware and software to work together to perform a certain computing requirement; the computing power to achieve the target result output by processing information data; and a new type of productivity that integrates information computing power, network carrying capacity, and data storage capacity, mainly providing services to society through computing power infrastructure.

[0054] The "computational power" (CP) described in this invention refers to the ability of a data center server to process data and output results. It is a comprehensive indicator of a data center's computing power, encompassing general computing power, supercomputing power, and intelligent computing power. The commonly used unit of measurement is floating-point operations per second (FLOPS, 1 EFLOPS = 10^18 FLOPS), with higher values ​​indicating stronger overall computing power. It is estimated that 1 EFLOPS is approximately equivalent to the computing power output of 5 Tianhe-2A supercomputers, 500,000 mainstream server CPUs, or 2 million mainstream laptops. The calculation formula is: CP = CP 通用 +CP 智能 +CP 超级 .

[0055] The "Network Power" (NP) mentioned in this invention refers to the performance of data transmission capability of computing facilities, which includes comprehensive capabilities such as network architecture, network bandwidth, transmission latency, intelligent management and scheduling, and involves network transmission within and between data centers. It is a comprehensive indicator for measuring network transmission scheduling capability.

[0056] The "Storage Power" (SP) described in this invention refers to the comprehensive capabilities of a data center in four aspects: data storage capacity, performance, security and reliability, and green and low-carbon operation. It is a comprehensive indicator for measuring the data storage capacity of a data center, including external storage devices such as storage arrays and internal storage devices within servers. The commonly used unit of measurement for storage capacity is exabytes (EB, 1EB = 2^60 bytes), the commonly used unit of measurement for performance is the number of read / write operations per second (IOPS / TB), and the disaster recovery ratio is an important indicator of security and reliability.

[0057] The "computing infrastructure" mentioned in this invention refers to a new type of information infrastructure that integrates information computing power, network carrying capacity, and data storage capacity, enabling centralized computing, storage, transmission, and application of information.

[0058] The "new information infrastructure" mentioned in this invention refers to network infrastructure such as 5G networks, fiber optic broadband networks, backbone networks, international communication networks, and satellite internet; computing infrastructure such as data centers, general computing centers, intelligent computing centers, and supercomputing centers; and new technology facilities such as artificial intelligence, blockchain, and quantum computing.

[0059] The “computing power” mentioned in this invention includes: “general computing power”, “intelligent computing power” and “supercomputing power”.

[0060] The "general computing power" mentioned in this invention refers to the computing power provided by servers based on CPU (Central Processing Unit) chips, which is used to support basic general computing such as cloud computing and edge computing.

[0061] The "intelligent computing power" mentioned in this invention refers to: a computing platform deployed on a large scale based on dedicated chips such as GPU (Graphics Processing Unit), FPGA (Field Programmable Gate Array), and ASIC (Application Specific Integrated Circuit) for various artificial intelligence innovative applications, such as natural language processing and machine vision.

[0062] The “supercomputing power” mentioned in this invention refers to the computing power provided by high-performance computing clusters such as supercomputers. It utilizes the centralized computing resources of multiple computer systems working in parallel and uses a dedicated operating system to handle extremely complex or data-intensive problems. It is mainly used for computing in cutting-edge scientific fields, such as planetary simulation, drug molecule design, and gene analysis.

[0063] The "intelligent computing" mentioned in this invention refers to computing driven by intelligent computing power (GPU, FPGA, ASIC, etc.), which is a general term for computing theories, methods, architectures and technical capabilities with characteristics such as data intensity and model-based computing. Its goal is to obtain better results by utilizing specific computing resources and appropriate computing methods according to the needs of the task.

[0064] The "intelligent computing cloud platform" mentioned in this invention refers to a cloud computing platform that provides intelligent computing services based on the hardware and software resources of an intelligent computing center.

[0065] The "intelligent computing center" described in this invention refers to a facility that, through the use of large-scale heterogeneous computing resources, including general-purpose computing power (CPU) and intelligent computing power (GPU, FPGA, ASIC, etc.), primarily provides the necessary computing power, data, and algorithms for artificial intelligence applications (such as deep learning model development, model fine-tuning, and model inference). The intelligent computing center encompasses facilities, hardware, and software, and can provide full-stack capabilities from underlying computing power to top-level application enablement.

[0066] The "intelligent computing center" mentioned in this invention includes, but is not limited to, "smart computing center".

[0067] The "intelligent computing center" mentioned in this invention, also known as an artificial intelligence computing center, is a type of computing infrastructure that provides computing power services, data services, and algorithm services required for artificial intelligence applications, based on artificial intelligence theory and adopting an artificial intelligence computing architecture.

[0068] The "computing center" mentioned in this invention refers to a facility that is mainly composed of infrastructure such as wind, thermal, hydro, and electricity, and IT hardware and software equipment, and has computing power, carrying capacity, and storage capacity, including general data centers, intelligent computing centers, supercomputing centers, etc.

[0069] The "supercomputing center" mentioned in this invention refers to a supercomputing data center, which is a data center based on supercomputers or large-scale computing clusters. It can provide large-scale computing, storage and network services and is widely used in aerospace, defense, oil exploration, climate modeling and genome sequencing and other application scenarios.

[0070] The “computing resources” mentioned in this invention refer to the technologies and facilities required for the development of the digital society that have the ability to compute, transmit, store and apply information, including but not limited to computing resources such as CPUs and GPUs, network resources such as switches and routers, storage resources such as storage arrays and distributed storage, security resources such as firewalls and intrusion detection systems, and supporting and guaranteeing resources such as wind, fire, water and electricity.

[0071] The "agent" described in this invention refers to an agent capable of perceiving its environment and taking actions to achieve specific goals. It can be software, hardware, or a system, possessing autonomy, adaptability, and interactivity. The agent perceives changes in the environment (e.g., through sensors or data input), makes judgments and decisions based on its learned knowledge and algorithms, and then executes actions to influence the environment or achieve predetermined goals. Agents are widely used in the field of artificial intelligence, commonly found in automated systems, robots, virtual assistants, and game characters. Their core lies in their ability to learn autonomously and continuously evolve to better complete tasks and adapt to complex environments.

[0072] The "intelligent agent factory" described in this invention refers to a management engine deployed within an intelligent computing cloud platform for automatically building intelligent agent systems. It automatically generates intelligent agent instances with decision-making, reasoning, execution, and collaboration capabilities by analyzing user needs, task objectives, or application scenarios, and performs lifecycle management on the generated intelligent agents.

[0073] Specifically, the intelligent agent factory includes at least one or a combination of the following functions:

[0074] 1. Based on the input task description or target constraints, automatically select or combine the functional units of the intelligent agent to form an executable intelligent agent structure;

[0075] 2. Break down the process of building an intelligent agent into multiple processing steps, and establish the execution order, condition triggering relationship, or loop relationship between the steps;

[0076] 3. Configure the agent with corresponding model capabilities, tool invocation capabilities, or external resource access permissions;

[0077] 4. Monitor the construction status of the agent during the construction process, and support dynamic adjustment, reconstruction or termination of the agent construction.

[0078] Through the aforementioned intelligent agent factory, the intelligent computing cloud platform can achieve automated generation and scheduling of intelligent agents without manual programming, thereby significantly reducing the construction cost of intelligent agents and improving the scalability and adaptability of intelligent agents in complex task processing scenarios.

[0079] This invention provides a method for generating intelligent agents through computing power on an intelligent computing cloud platform, applied to the intelligent agent factory built into the intelligent computing cloud platform. See [link to relevant documentation]. Figure 1 As shown, Figure 1 This is a flowchart illustrating the method for generating intelligent agents using computing power in the intelligent computing cloud platform according to the present invention. The method includes:

[0080] Step S1: After the agent factory is initialized, agent instances are created in the agent factory;

[0081] Step S2: Perform natural language parsing on the creation requirements of the user-input text format to determine the user's capability requirements for autonomously constructing intelligent agents, and determine whether the basic intelligent agent instance can meet the capability requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools;

[0082] Step S3: If the basic agent instance cannot meet the capability requirements, load the toolset, determine multiple first tools that can meet the capability requirements from the toolset, call the computing power of the intelligent computing cloud platform, and assemble all the first tools into the agent instance;

[0083] Step S4: If the basic agent instance can meet the capability requirements, create a basic agent instance and use the basic agent instance as the target agent.

[0084] It should be noted that the basic tools in this invention refer to the core capabilities and information processing methods designed to be executed on the intelligent agent, and may include at least one of the following:

[0085] Natural Language Understanding (NLU) capabilities, large-scale knowledge base and learning capabilities, Natural Language Generation (NLG) capabilities, multimodal processing capabilities, code understanding and generation capabilities, and context management capabilities.

[0086] The basic agent instance has native basic tools. Even when users do not require specific capabilities, the basic agent instance can meet their capability requirements for the agent, eliminating the need for users to build the agent themselves. Therefore, step S2 of this application determines whether the basic agent instance can meet the capability requirements. If the basic agent instance cannot meet the capability requirements, the process proceeds to the step of building the agent independently (i.e., step S3), ensuring flexible adaptation to the user's actual requirements for the agent and avoiding waste of computing resources.

[0087] Regarding step S3 of the present invention, it should be noted that the toolset is a pre-configured collection of various tools. The toolset can be a collection of tools from a built-in tool scheduler, an external service scheduler, a pipeline scheduler, or a workflow scheduler. Based on the user's capability requirements for the constructed intelligent agent, a first tool is determined from the toolset. Further, the computing power of the intelligent computing cloud platform is invoked to integrate all the first tools into the intelligent agent, resulting in the target intelligent agent that meets the user's capability requirements.

[0088] In this invention, the intelligent agent factory built into the intelligent computing cloud platform executes the following steps: Step S1: After initialization, intelligent agent instances are created within the intelligent agent factory; Step S2: Natural language parsing is performed on the user-inputted text format creation requirements to determine the user's capability requirements for autonomously constructing intelligent agents, and whether the basic intelligent agent instance can meet these requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools; Step S3: If the basic intelligent agent instance cannot meet the capability requirements, a toolset is loaded, and multiple first tools that can meet the capability requirements are determined from the toolset. The computing power of the intelligent computing cloud platform is then invoked to assemble all the first tools into the intelligent agent instance; Step S4: If the basic intelligent agent instance can meet the capability requirements, the basic intelligent agent instance is created, and this basic intelligent agent instance is used as the target intelligent agent. In this invention, the intelligent agent factory built into the intelligent computing cloud platform can invoke the computing power of the intelligent computing cloud platform based on the user's natural language to construct intelligent agents that meet the capability requirements.

[0089] In some embodiments, step S4 may optionally include:

[0090] Step S41: Create a basic agent instance in the agent factory using the singleton creation method.

[0091] In this invention, the singleton creation method is based on the Singleton Pattern. The Singleton Pattern is a creational design pattern that ensures a class has only one instance and provides a single global access point. By employing the Singleton creation method to create basic agent instances in the agent factory, this invention improves thread safety and ensures unified management of agent system resources.

[0092] In some embodiments, optionally, a double-checked locking pattern is employed to ensure the uniqueness and thread safety of factory instances. Specifically, the singleton creation algorithm is as follows:

[0093] INPUT: None

[0094] OUTPUT: Factory Instance

[0095] Step 1: Check if the instance exists

[0096] IF factory instance is empty:

[0097] Step 2: Acquire thread lock

[0098] Acquire thread lock()

[0099] Step 3: Double-check the instance.

[0100] If the factory instance is still empty:

[0101] Step 4: Create a new instance

[0102] Factory Instance ← Create a new factory object()

[0103] Initialize Component Manager()

[0104] Set initialization complete flag()

[0105] Release thread lock()

[0106] RETURN Factory Instance

[0107] In some embodiments, step S41 may optionally include:

[0108] Step S411: Obtain the user's instruction to create a basic intelligent agent instance via the interactive terminal;

[0109] Step S412: Parse the creation request to obtain the agent identifier of the basic agent instance that the user requests to create, and the context information describing the capabilities of the basic agent instance; determine the basic tools from the preset basic tool set based on the agent identifier and the context information.

[0110] Step S413: Assemble the basic tools into the agent instance to obtain the basic agent instance.

[0111] In this invention, the creation request can be an instruction that the user inputs into the intelligent agent factory in natural language. For example, if the user inputs "create an intelligent agent that can draw a bar chart based on Excel data", the parsing result of the creation request includes: the identifier of the intelligent agent that can process table data in Excel (i.e., intelligent agent identifier), and the preceding and following information (i.e., context information) of "create an intelligent agent that can draw a bar chart based on Excel data".

[0112] Understandably, the agent identifier determines the type of agent, while contextual information allows for a more precise understanding of the requirements for the agent's capabilities, as encapsulated in the phrase "create an agent capable of plotting bar charts based on Excel data." For example, a sentence in the text might specify the type of data in the Excel file, such as financial data or experimental data. Understanding these precise requirements based on contextual information improves the accuracy of the determined basic tools relative to the user's creation request, thereby ensuring the accurate generation of the basic agent instance.

[0113] It should be noted that the basic toolset can be a pre-configured toolset in the intelligent agent factory, including multiple native basic tools. In some embodiments, the basic toolset may optionally be the toolset in the built-in tool caller. In practical applications, the user determines the basic tools from the basic toolset of the built-in tool caller.

[0114] Understandably, the toolset in step S3 includes not only the pre-configured tools in the agent factory, but also the tools in the callers that the agent factory can access (e.g., the schedulers include: built-in tool schedulers, external service schedulers, pipeline schedulers, and workflow schedulers). Compared to the basic toolset, the toolset has a wider variety and greater number of tools, enabling flexible tool configuration according to the user's functional requirements.

[0115] In some embodiments, step S3 may optionally include:

[0116] Step S31: Arrange the first tools according to the dependencies between them; the dependencies represent the execution order of the first tools during the execution process and the calling relationship between the first tools.

[0117] Step S32: Assemble all the first tools into the agent instance according to the arrangement result.

[0118] In this invention, the effect achieved by the orchestration is that the execution order of each first tool conforms to the execution order of the dependency relationship representation, and a calling relationship conforming to the dependency relationship representation is established between each first tool, so that the first tools can work together to complete a specific task.

[0119] In some embodiments, optionally, a pre-trained orchestration model can be used to orchestrate the functional modules in the functional module set according to dependencies.

[0120] Regarding dependencies, it is understood that in some embodiments, optionally, the orchestration large model infers dependencies during the orchestration process.

[0121] Understandably, the orchestration model is trained before deployment, enabling it to understand the execution order and calling relationships between functional modules and to orchestrate these modules based on input dependencies. The specific training process of the orchestration model described above is not the focus of this invention, and many general-purpose large models (e.g., DeepSeek) can also implement orchestration functions. Therefore, this invention will not elaborate on the training process.

[0122] In some embodiments, the dependencies may optionally be preset by the user and stored in a preset storage space, and the dependencies may be retrieved from the preset storage space before executing step S31.

[0123] In some embodiments, optionally, step S3 is followed by:

[0124] Step S5: Using the agent instance that has completed the integration of the first tool as the first agent instance, perform tool repeatability detection on the first agent instance and obtain the detection result;

[0125] Step S6: If the detection result indicates that there are duplicate tools in the first agent instance, perform tool deduplication processing on the first agent instance to obtain the target agent.

[0126] Understandably, duplicate tools can interfere with each other, causing a waste of computing power when the target intelligent agent actually performs the task. The present invention addresses this by: step S5: taking the intelligent agent instance that has completed the integration of the first tool as the first intelligent agent instance, performing tool duplication detection on the first intelligent agent instance, and obtaining the detection result; step S6: if the detection result indicates that the first intelligent agent instance has duplicate tools, performing tool deduplication processing on the first intelligent agent instance to obtain the target intelligent agent, thus ensuring the efficient operation of the target intelligent agent.

[0127] The deduplication mechanism of this invention uses a set data structure to track added tools, avoiding the repeated loading of tools with the same function.

[0128] In some embodiments, optionally, step S6 is followed by:

[0129] Step S7: Cache the target agent to the pre-allocated storage space on the intelligent computing cloud platform, and generate a unique cache key representing the target agent cached in the storage space.

[0130] In this invention, the target intelligent agent is cached in a pre-allocated storage space on an intelligent computing cloud platform, and a unique cache key representing the target intelligent agent cached in the storage space is generated. This allows users to quickly retrieve the target intelligent agent from the intelligent computing cloud platform by triggering the unique cache key, improving the efficiency of target intelligent agent usage. The setting of the unique cache key also supports rapid retrieval and lifecycle management of the target intelligent agent.

[0131] The following description is based on specific embodiments:

[0132] By constructing a unified factory management architecture and a multi-layered tool integration system, the automated creation and efficient management of intelligent agents are achieved. This method includes the following core technical solutions:

[0133] I. System Overall Architecture

[0134] See Figure 2 As shown, the intelligent agent automatic generation system adopts a factory pattern design and mainly includes the following components:

[0135] (a) Intelligent body factory

[0136] The agent factory, as the core control module of the system, is responsible for the unified creation and management of agents, including:

[0137] Singleton Factory Manager: Employs a thread-safe singleton pattern to ensure unified management of system resources.

[0138] Component Manager Cluster: Includes Configuration Manager, Skill Manager, External Service Manager, Tool Factory, etc.

[0139] Cache Management System: Enables efficient caching and lifecycle management of agent instances.

[0140] State synchronization mechanism: Ensures state consistency and data synchronization among multiple instances.

[0141] (II) Tool Integration Framework

[0142] The tool integration framework enables unified management and dynamic integration of various types of tools:

[0143] Built-in tool manager: Manages the system's predefined core functional tools.

[0144] External service adapter: Supports dynamic access to external services using standard protocols, such as the MCP protocol.

[0145] API Tool Builder: Encapsulates external API services into standardized tool interfaces.

[0146] Tool deduplication mechanism: Intelligently detects and processes duplicate tools to avoid functional conflicts.

[0147] (III) Dynamic Configuration System

[0148] The dynamic configuration system provides automated management and optimization of agent configuration:

[0149] Runtime configuration management: Supports dynamic updates and hot reloading of agent configurations.

[0150] Model Provider Detection: Automatically identifies and adapts different major language model providers based on model name.

[0151] Tool combination strategy: Automatically select the optimal tool combination based on agent type and needs.

[0152] Configuration verification mechanism: Ensures the integrity and validity of the configuration.

[0153] (iv) Storage Management Layer

[0154] The storage management layer provides unified data storage and state management services:

[0155] Checkpoint storage system: Supports persistence and recovery of session state, preferably using PostgreSQL database.

[0156] Distributed storage adaptation: compatible with multiple storage backends and supports horizontal scaling.

[0157] Cache optimization mechanism: Improve data access performance through caching system.

[0158] Data consistency guarantee: Ensure data consistency in a distributed environment.

[0159] (v) Tool Optimization Engine

[0160] The tool optimization engine enables intelligent combination and performance optimization of intelligent agent tools:

[0161] Capability evaluator: Analyzes the functional scope, performance metrics, and applicable scenarios of the tool.

[0162] Conflict detector: Identifies functional overlaps and potential conflicts between tools.

[0163] Combinatorial optimizer: Optimizes tool combination strategies based on preset rules and performance metrics.

[0164] Performance monitor: Real-time monitoring of tool usage and performance.

[0165] The process for automatically generating intelligent agents includes steps A1 to A5.

[0166] Specifically:

[0167] Step A1: See Figure 3 As shown, factory initialization and component assembly.

[0168] (1-1) Creation of a thread-safe singleton factory

[0169] The double-checked locking pattern is used to ensure the uniqueness and thread safety of factory instances:

[0170] Singleton creation algorithm:

[0171] INPUT: None

[0172] OUTPUT: Factory Instance

[0173] Step 1: Check if the instance exists

[0174] IF factory instance is empty:

[0175] Step 2: Acquire thread lock

[0176] Acquire thread lock()

[0177] Step 3: Double-check the instance.

[0178] If the factory instance is still empty:

[0179] Step 4: Create a new instance

[0180] Factory Instance ← Create a new factory object()

[0181] Initialize Component Manager()

[0182] Set initialization complete flag()

[0183] Release thread lock()

[0184] RETURN factory instance.

[0185] (1-2) Unified assembly by component manager

[0186] Initialize each component manager in an orderly manner according to its dependencies:

[0187] Component assembly algorithm:

[0188] Step 1: Initialize basic components

[0189] Configuration Manager ← Create Configuration Manager instance()

[0190] Skill Manager ← Create Skill Manager Instance()

[0191] External Service Manager ← Create an External Service Manager instance()

[0192] Tool Factory ← Create a Tool Factory instance()

[0193] Step 2: Advanced Component Initialization

[0194] Agent Service ← Create an Agent Service instance (Configuration Manager)

[0195] Cache Manager ← Create Cache Manager Instance()

[0196] Step 3: Storage connection initialization

[0197] Storage connection ← Initialize database connection()

[0198] Checkpoint Storage ← Configure checkpoint storage service()

[0199] Step 4: Set up dependencies between components

[0200] Establish dependencies and communication mechanisms between components.

[0201] Step A2: See Figure 4 As shown, the intelligent agent is dynamically constructed and configured.

[0202] (2-1) Configuration-driven agent construction

[0203] Automatically generate runtime configuration based on agent identifier and context information:

[0204] Configure the generation algorithm:

[0205] INPUT: Agent ID (agent_id), Chat Context (chat_context)

[0206] OUTPUT: Standardized configuration object

[0207] Step 1: Building the basic configuration

[0208] Runtime configuration ← Create an empty configuration object()

[0209] Runtime configuration.Settings("agent_id", agent_id).

[0210] Step 2: Context Information Injection

[0211] IF chat_context is not empty:

[0212] Runtime configuration.Settings("chat_context", chat_context)

[0213] User Identifier ← Extract User Identifier (chat_context)

[0214] ELSE:

[0215] User ID ← "default_user".

[0216] Step 3: Configure Integrity Verification

[0217] Validate the integrity of required fields (runtime configuration)

[0218] Verify the correctness of the configuration format (runtime configuration).

[0219] Step 4: Configure standardized processing

[0220] Standardized Configuration ← Configuration Manager. Update Runtime Configuration (Runtime Configuration)

[0221] RETURN Standard Configuration.

[0222] (2-2) See Figure 5 As shown, Figure 5 This illustrates the process of dynamically integrating multiple types of tools.

[0223] Step A3: See Figure 6 As shown, multiple types of tools are integrated and optimized in a unified manner.

[0224] (3-1) Layered tool loading strategy and type identification

[0225] Intelligent tool loading is implemented based on agent type and tool priority:

[0226] Tool loading decision algorithm:

[0227] INPUT: Agent ID (agent_id), Agent configuration data (agent_data)

[0228] OUTPUT: A collection of tools and a list of tool names.

[0229] Step 1: Agent type determination

[0230] Whether to use the default smart agent ← (agent_id == "default_builtin_agent").

[0231] Step 2: Tool loading strategy selection

[0232] IF whether the default agent is true:

[0233] Toolset ← Empty List

[0234] Tool Name List ← Empty List

[0235] Log entry ("Default agent skips tool loading")

[0236] RETURN (tool set, list of tool names).

[0237] Step 3: Load the layering tool

[0238] Toolset ← Empty List

[0239] Tool Name List ← Empty List

[0240] # First layer: Loading external service tools

[0241] External service tools, External service tool name ← External service manager. Configuration tool (agent_data)

[0242] Toolset. Extensions (External Service Tools)

[0243] List of tool names.Extensions (external service tool names)

[0244] # Second Layer: Loading Skill Tools

[0245] Skill tools, Skill tool name ← Building skill tools (agent_data)

[0246] Toolset.Extended (Skill Tools)

[0247] Tool Name List.Extension(Skill Tool Name)

[0248] RETURN (tool set, list of tool names).

[0249] (3-2) Intelligent duplicate detection and deduplication mechanism

[0250] Implement efficient deduplication tools using set data structures:

[0251] Deduplication algorithm for tools:

[0252] INPUT: Agent configuration data (agent_data)

[0253] OUTPUT: A collection of deduplicated skill tools.

[0254] Step 1: Initialize the deduplication tracking set

[0255] Skill set added ← Create empty set()

[0256] Skills and Tools List ← Empty List

[0257] Skill tool name list ← Empty list.

[0258] Step 2: Add default skills in batches

[0259] Agent name ← agent_data.get("name", "")

[0260] Log entry ("Add all special skills to all agents")

[0261] FOR EACH skill_name, utility_object IN skill_manager.special_skill_map.items():

[0262] Skills and Tools List. Add (Tool Object)

[0263] List of skill tool names. Add (skill name)

[0264] A skill set has been added. Add (skill name).

[0265] Step 3: Configure skill deduplication

[0266] FOR EACH skill configuration IN agent_data.get("skills", []):

[0267] Skill type ← Skill configuration.get("skill_type", "")

[0268] Skill Name ← Skill Configuration.Get("name", "")

[0269] IF Skill Type == "mmalaya_builtin":

[0270] IF skill name IN added skill set:

[0271] Log entry (f"Skill {Skill Name} has been added using default logic, skip duplicate additions")

[0272] CONTINUE

[0273] IF Skill Name IN SkillManager.Special Skill Map:

[0274] Tool Object ← Skill Manager. Special Skill Map [Skill Name]

[0275] Skills and Tools List. Add (Tool Object)

[0276] List of skill tool names. Add (skill name)

[0277] A skill set has been added. Add (skill name)

[0278] ELIF Skill Type == "agent_as_tool":

[0279] Log warning (f"Temporarily skip agent_as_tool type skills: {skill name}")

[0280] CONTINUE

[0281] ELSE:

[0282] Security Skill Name ← Skill Manager. Get Security Skill Name (Skill Configuration)

[0283] IF Security Skill Name IN Added Skill Set:

[0284] Log entry (f"Skill {Safety Skill Name} has been added, skip duplicate additions")

[0285] CONTINUE

[0286] Tool Object ← Tool Factory. Create Tool (Skill Configuration, Skill Manager)

[0287] Skills and Tools List. Add (Tool Object)

[0288] List of skill tool names. Add (security skill name).

[0289] Skill set added. Add (security skill name)

[0290] RETURN (List of skills and tools, List of skill and tool names).

[0291] (3-3) Tool Priority and Compatibility Management:

[0292] Tool prioritization strategy:

[0293] Special skills and tools priority = highest (core system functions)

[0294] MCP protocol tool priority = Medium (standardized external service)

[0295] API skills and tools priority = lowest (custom business logic)

[0296] Compatibility check rules:

[0297] IF tool type == "mmalaya_builtin" THEN

[0298] Check if the tool is defined in SPECIAL_SKILLS_MAP

[0299] If THEN is not defined, log the error and skip.

[0300] IF tool type == "agent_as_tool" THEN

[0301] Skip this for now (requires special handling logic).

[0302] ELSE tool type is API skill THEN

[0303] Generate security tool name

[0304] Create a LangChain tool wrapper.

[0305] (3-4) Tool integration status monitoring and log recording:

[0306] Tool integration monitoring process:

[0307] FOR each tool type IN [Special Skills, MCP Tools, API Skills]:

[0308] Record tool loading start time

[0309] Count the number of tools that were successfully loaded

[0310] Tools for recording failures and reasons for failure

[0311] The calculation tool takes a long time to load.

[0312] Generate tool integration summary report:

[0313] - Total number of tools: {total_count}

[0314] - Number of special skills: {special_skills_count}

[0315] - Number of MCP tools: {mcp_tools_count}

[0316] - Number of API skills: {api_skills_count}

[0317] - Number of loading failures: {failed_count}

[0318] - Total time elapsed: {total_time} ms

[0319] IF is the default agent THEN.

[0320] Log: "Default agent skips tool loading (for query thread only)"

[0321] Step A4: See Figure 7 As shown, the model provider adapts to detection and agent assembly.

[0322] (4-1) Adaptive Model Provider Detection Mechanism

[0323] Automatically identify and adapt to different large language model providers based on model name:

[0324] Model provider detection algorithm:

[0325] INPUT: Runtime configuration config

[0326] OUTPUT: The initialized model instance.

[0327] Step 1: Obtain model configuration information

[0328] Model Name ← Configuration Manager.Get Configuration Value("api_llm_model_name", config)

[0329] Base URL ← Configuration Manager.Get Configuration Value("api_url", config)

[0330] API Key ← Configuration Manager.Get Configuration Value("api_key", config).

[0331] Step 2: Intelligent detection by the model provider

[0332] IF Model Name AND Base URL AND API Key:

[0333] Log the following: (f"Using a custom LLM model: {model name}, base URL: {base URL}")

[0334] Model Provider ← Detection Model Provider (Model Name)

[0335] Log (f"Inference model provider: {model provider}")

[0336] Basic Model ← Initialize Chat Model (

[0337] model = model name,

[0338] model_provider = model provider

[0339] base_url = base URL,

[0340] api_key = API key

[0341] temperature=0.1,

[0342] streaming=True )

[0344] ELSE:

[0345] Log warning ("Custom LLM not configured, using default model")

[0346] Basic Model ← Initialize Chat Model (

[0347] model="openai:gpt-4o-mini",

[0348] streaming=True )

[0350] RETURN base model.

[0351] (4-2) Pattern matching algorithm of model provider

[0352] Intelligent matching based on model name keywords:

[0353] Provider detection algorithm:

[0354] INPUT: model_name

[0355] OUTPUT: Provider identifier string

[0356] Model name lowercase ← model_name.convert to lowercase()

[0357] IF "claude" IN model_name_lowercase:

[0358] RETURN "anthropic"

[0359] ELIF "gemini" IN model_name (lowercase):

[0360] RETURN "google_genai"

[0361] ELIF "cohere" IN model_name (lowercase):

[0362] RETURN "cohere"

[0363] ELIF "mistral" IN model_name (lowercase):

[0364] RETURN "mistralai"

[0365] ELSE:

[0366] RETURN "openai" # Default provider.

[0367] Step A5: See Figure 8 As shown, this relates to agent instance cache management and performance optimization.

[0368] (5-1) Intelligent caching strategy and instance management

[0369] Achieve efficient caching and lifecycle management of agent instances:

[0370] Cache management algorithm:

[0371] INPUT: Agent ID (agent_id), User Context (user_context)

[0372] OUTPUT: Agent instance.

[0373] Step 1: Generate cache key

[0374] Cache key ← Generate cache key (agent_id, user_context).

[0375] Step 2: Cache Instance Check

[0376] Use cache lock():

[0377] IF cache key IN default agent cache:

[0378] Log (f"Agent instance using cache: {cache key}")

[0379] RETURN Default agent cache [cache key].

[0380] Step 3: Creating a new instance

[0381] Log (f"Create a new agent instance and cache it: {cache key}")

[0382] IF User ID exists:

[0383] Chat Context ← Create a simple chat context (user identifier)

[0384] ELSE:

[0385] Chat context ← null

[0386] Default agent ← Create agent(agent_id, chat context).

[0387] Step 4: Cache storage

[0388] Use cache lock():

[0389] Default agent cache [Cache key] ← Default agent

[0390] RETURN is the default agent.

[0391] This invention provides a device for generating intelligent agents through computing power on an intelligent computing cloud platform, which is applied to the intelligent agent factory built into the intelligent computing cloud platform. See [link to device]. Figure 9 As shown, Figure 9 This is a schematic diagram of the device for generating intelligent agents through computing power in the intelligent computing cloud platform of the present invention. The device 90 for generating intelligent agents through computing power in the intelligent computing cloud platform includes:

[0392] Module 91 is used to create agent instances in the agent factory after the agent factory is initialized.

[0393] The confirmation module 92 is used to perform natural language parsing on the creation requirements of the text format input by the user, determine the user's ability requirements for autonomously constructing intelligent agents, and determine whether the basic intelligent agent instance can meet the ability requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools;

[0394] The first execution module 93 is configured to, if the basic intelligent agent instance cannot meet the capability requirements, load a toolset, determine multiple first tools from the toolset that can meet the capability requirements, call the computing power of the intelligent computing cloud platform, and assemble all the first tools into the intelligent agent instance;

[0395] The second execution module 94 is used to create the basic intelligent agent instance if the basic intelligent agent instance can meet the capability requirements, and use the basic intelligent agent instance as the target intelligent agent.

[0396] In some embodiments, optionally, the second execution module 94 is further configured to create the basic agent instance in the agent factory using a singleton creation method.

[0397] In some embodiments, optionally, the second execution module 94 is further configured to obtain a creation request sent by the user through the interactive terminal to create the basic intelligent agent instance;

[0398] The second execution module 94 is further configured to parse the creation request, obtain the agent identifier of the basic agent instance to be created by the user, and obtain context information describing the capabilities of the basic agent instance; and determine the basic tool from a preset set of basic tools based on the agent identifier and the context information.

[0399] The second execution module 94 is further configured to assemble the basic tools into the agent instance to obtain the basic agent instance.

[0400] Optionally, in some embodiments, the first execution module 93 is further configured to orchestrate the first tools according to the dependencies between them; the dependencies represent the execution order of the first tools during the execution process and the calling relationship between them.

[0401] The first execution module 93 is further configured to assemble all the first tools into the agent instance according to the orchestration result.

[0402] In some embodiments, optionally, the first execution module 93 is further configured to use the agent instance that has completed the integration of the first tool as the first agent instance, perform tool repeatability detection on the first agent instance, and obtain the detection result;

[0403] The first execution module 93 is further configured to perform tool deduplication processing on the first intelligent agent instance to obtain the target intelligent agent if the detection result indicates that the first intelligent agent instance has duplicate tools.

[0404] Optionally, in some embodiments, the first execution module 93 is further configured to cache the target agent to a pre-allocated storage space on the intelligent computing cloud platform and generate a unique cache key representing the target agent cached in the storage space.

[0405] The intelligent computing cloud platform provided by this invention can realize the various processes implemented in the method embodiment through the device for generating intelligent agents with computing power, and achieve the same technical effect. To avoid repetition, it will not be described again here.

[0406] This invention provides an electronic device 100, see [link to documentation]. Figure 10 As shown, Figure 10 This is a schematic block diagram of the electronic device 100 of the present invention, including a processor 101, a memory 102, and a program or instructions stored in the memory 102 and executable on the processor 101. When the program or instructions are executed by the processor, they implement the steps in any of the intelligent computing cloud platform methods of the present invention for generating intelligent agents through computing power.

[0407] This invention provides a readable storage medium on which a program or instruction is stored. When the program or instruction is executed by a processor, it implements the various processes of the embodiment of the method for generating intelligent agents by computing power in the intelligent computing cloud platform as described above, and can achieve the same technical effect. To avoid repetition, it will not be described again here.

[0408] The readable storage medium may include, for example, read-only memory (ROM), random access memory (RAM), magnetic disk, or optical disk. In some examples, the readable storage medium may be a non-transient readable storage medium.

[0409] The present invention also provides a computer program product, including computer instructions, which, when executed by a processor, implement various processes of the method embodiment of generating intelligent agents through computing power by the intelligent computing cloud platform described above, and can achieve the same technical effect. To avoid repetition, they will not be described again here.

[0410] It should be noted that, in this document, 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. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element.

[0411] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of 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 the present invention, 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 (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of the present invention.

[0412] The embodiments of the present invention have been described above with reference to the accompanying drawings. However, the present invention is not limited to the specific embodiments described above. The specific embodiments described above are merely illustrative and not restrictive. Those skilled in the art can make many other forms under the guidance of the present invention without departing from the spirit and scope of the claims, and all of these forms are within the protection scope of the present invention.

Claims

1. A method for generating intelligent agents through computing power on an intelligent computing cloud platform, characterized in that, The method, applied to the intelligent agent factory built into the intelligent computing cloud platform, includes: Step S1: After the agent factory is initialized, agent instances are created in the agent factory; Step S2: Perform natural language parsing on the creation requirements of the text format input by the user to determine the user's ability requirements for autonomously constructing intelligent agents, and determine whether the basic intelligent agent instance can meet the ability requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools; Step S3: If the basic intelligent agent instance cannot meet the capability requirements, load the toolset, determine multiple first tools from the toolset that can meet the capability requirements, call the computing power of the intelligent computing cloud platform, and assemble all the first tools into the intelligent agent instance; Step S4: If the basic agent instance can meet the capability requirements, create the basic agent instance and use the basic agent instance as the target agent; Step S3 includes: Step S31: Arrange the first tools according to the dependencies between them; the dependencies represent the execution order of the first tools during the execution process and the calling relationship between the first tools. Step S32: According to the arrangement result, assemble all the first tools into the agent instance; Step S31 includes: using a pre-trained orchestration model to orchestrate the functional modules in the functional module set according to the dependency relationship; Step S4 includes: Step S41: Create the basic agent instance in the agent factory using the singleton creation method; Step S41 includes: Step S411: Obtain the creation request sent by the user through the interactive terminal to create the basic intelligent agent instance; Step S412: Parse the creation request to obtain the agent identifier of the basic agent instance that the user requests to create, and obtain the context information describing the capabilities of the basic agent instance; determine the basic tool from the preset basic tool set based on the agent identifier and the context information; Step S413: Assemble the basic tools into the agent instance to obtain the basic agent instance.

2. The method for generating intelligent agents through computing power in the intelligent computing cloud platform according to claim 1, characterized in that, After step S3, the following is included: Step S5: Using the agent instance that has completed the integration of the first tool as the first agent instance, perform tool repeatability detection on the first agent instance to obtain the detection result; Step S6: If the detection result indicates that the first agent instance has duplicate tools, perform tool deduplication processing on the first agent instance to obtain the target agent.

3. The method for generating intelligent agents through computing power in the intelligent computing cloud platform according to claim 2, characterized in that, Step S6 is followed by: Step S7: Cache the target intelligent agent to the pre-allocated storage space on the intelligent computing cloud platform, and generate a unique cache key representing the target intelligent agent cached in the storage space.

4. A device for generating intelligent agents through computing power on an intelligent computing cloud platform, characterized in that, The device, applied to the intelligent agent factory built into the intelligent computing cloud platform, includes: A creation module is used to create agent instances in the agent factory after the agent factory is initialized. The confirmation module is used to perform natural language parsing on the creation requirements of the text format input by the user, determine the user's ability requirements for autonomously constructing intelligent agents, and determine whether the basic intelligent agent instance can meet the ability requirements; wherein, the basic intelligent agent instance is an intelligent agent with basic tools; The first execution module is configured to, if the basic intelligent agent instance cannot meet the capability requirements, load a toolset, determine multiple first tools from the toolset that can meet the capability requirements, call the computing power of the intelligent computing cloud platform, and assemble all the first tools into the intelligent agent instance; The second execution module is used to create the basic intelligent agent instance if the basic intelligent agent instance can meet the capability requirements, and use the basic intelligent agent instance as the target intelligent agent. The first execution module is further configured to orchestrate the first tools according to the dependencies between them; the dependencies represent the execution order of the first tools during the execution process and the calling relationship between them. The first execution module is further configured to assemble all the first tools into the agent instance according to the orchestration result; The first execution module is further configured to use a pre-trained orchestration model to orchestrate the functional modules in the functional module set according to the dependencies; The second execution module is further configured to create the basic agent instance in the agent factory using a singleton creation method; The second execution module is further configured to obtain a creation request from the user via an interactive terminal to create the basic intelligent agent instance; The second execution module is further configured to parse the creation request, obtain the agent identifier of the basic agent instance to be created by the user, and obtain context information describing the capabilities of the basic agent instance; and determine the basic tool from a preset set of basic tools based on the agent identifier and the context information. The second execution module is further configured to assemble the basic tools into the agent instance to obtain the basic agent instance.

5. An electronic device, characterized in that: It includes a processor, a memory, and a program or instructions stored in the memory and executable on the processor, wherein when the program or instructions are executed by the processor, they implement the steps in the method of generating intelligent agents by computing power in the intelligent computing cloud platform as described in any one of claims 1 to 3.

6. A readable storage medium, characterized in that: The program or instructions are stored on the readable storage medium, and when the program or instructions are executed by the processor, they implement the steps in the method of generating intelligent agents by computing power in the intelligent computing cloud platform as described in any one of claims 1 to 3.

7. A computer program product, characterized in that, It includes computer instructions, which, when executed by a processor, implement the steps of the method for generating intelligent agents by computing power using an intelligent computing cloud platform as described in any one of claims 1 to 3.

Images