Intelligent agent unit application method and device

Abstract

The invention discloses an agent unit application method and device. The agent unit application method comprises the following steps: receiving a user request; analyzing the user request to obtain a target function corresponding to the user request; based on the target function, at least one target intelligent agent unit matched with the target function is called from the intelligent agent unit set, each intelligent agent unit is provided with an independent storage space and an independent vector space, and the intelligent agent unit can execute the intelligent agent function corresponding to the preset function after being loaded; and loading the at least one target agent unit to execute the user request.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and more specifically to a method and apparatus for applying intelligent agent units. Background Technology

[0002] In the field of artificial intelligence technology, AI Agent (AI agent, or simply agent) is the main technology for realizing the automation of complex tasks and intelligent interaction. The agent usually uses multiple memory functional units to maintain its state, store knowledge and maintain the context of interaction with the user. These memory functional units can be responsible for different data processing or interaction functions.

[0003] Currently, common communication frameworks (such as MCP, A2A, etc.) cause intelligent agent systems to face problems such as low modularity and poor coordination efficiency when integrating memory functional units from different sources and with different functions, thus affecting the efficiency and application accuracy of intelligent agents. Summary of the Invention

[0004] In view of the above, this application provides the following technical solution:

[0005] A method for applying intelligent agent units, comprising:

[0006] Receive user requests;

[0007] The user request is parsed to obtain the target function corresponding to the user request;

[0008] Based on the target function, at least one target intelligent agent unit matching the target function is called from the intelligent agent unit set. Each intelligent agent unit is configured with an independent storage space and vector space, and after being loaded, the intelligent agent unit can execute the intelligent agent function corresponding to its preset function.

[0009] Load the at least one target intelligent agent unit to execute the user request.

[0010] Optionally, the step of calling at least one target intelligent agent unit matching the target function from the set of intelligent agent units based on the target function includes:

[0011] Based on the target function, a target operation type is determined; wherein, the target operation type is at least one of the operation type set, and the operation type set represents a set of operation instructions used to adjust the application state of the agent unit;

[0012] Based on the target operation type, a target invocation message is generated, the target invocation message including a first field corresponding to the target operation type and a second field of the intelligent agent unit to be invoked corresponding to the target operation type;

[0013] The target invocation message is matched with the pre-configured description fields of each intelligent agent unit in the intelligent agent unit set; the pre-configured description fields of the intelligent agent unit represent metadata of the attribute information of the intelligent agent unit.

[0014] At least one intelligent agent unit whose matching result satisfies the matching condition is identified as the target intelligent agent unit.

[0015] Optionally, before loading the target agent unit, the method further includes:

[0016] The target intelligent agent unit is verified based on the verification field carried in the target invocation message and the digital fingerprint pre-configured in the target intelligent agent unit.

[0017] In response to the successful verification of the target intelligent agent unit, the target intelligent agent unit is loaded.

[0018] Optionally, the step of calling at least one target agent matching the target function from the set of agent units based on the target function includes:

[0019] Based on the target function, multiple target intelligent agent units that need to be called concurrently are identified, so that the multiple target intelligent agent units can collaboratively process the user request.

[0020] Loading the at least one target intelligent agent unit to execute the user request includes:

[0021] Based on the task attributes corresponding to the user request, the processing priority of the at least one target intelligent agent unit is determined;

[0022] According to the processing priority, the processing results output by each target intelligent agent unit are obtained;

[0023] The processing results are integrated to generate an execution result corresponding to the user request.

[0024] Optionally, loading the at least one target agent unit to execute the user request includes:

[0025] Load the at least one target intelligent agent unit, and filter candidate data associated with the processing task corresponding to the user request from the data stored in the target intelligent agent unit;

[0026] The usage priority of the candidate data is determined based on the business priority and / or user intent of the target intelligent agent unit;

[0027] Based on the usage priority, target data is determined from the candidate data;

[0028] The user request is executed using the target data.

[0029] Optionally, it also includes:

[0030] In response to the update of the user request, at least one target intelligent agent unit to be loaded is re-determined based on the updated user request;

[0031] The updated user request is executed based on the re-determined target agent unit to be loaded.

[0032] Optionally, loading the at least one target agent unit to execute the user request includes:

[0033] The context information of the user request is input into the target intelligent agent unit;

[0034] The context is reasoned through the vector space of the target intelligent agent unit to generate an execution result corresponding to the user request.

[0035] Optionally, the method further includes:

[0036] Monitor the lifecycle status of each target intelligent agent unit;

[0037] When the lifecycle state of the target intelligent agent unit meets the unloading condition, the target intelligent agent unit is unloaded.

[0038] Optionally, the method further includes:

[0039] In response to the recognition that the operation type field in the target call message is an extended operation type, the extended processing logic corresponding to the extended operation type is invoked;

[0040] The extended operation type includes at least one of emotion synchronization and instruction optimization, and the extended processing logic is provided by the extended function interface implemented in the target intelligent agent unit.

[0041] An intelligent agent unit application device, comprising:

[0042] The receiving module is used to receive user requests;

[0043] The parsing module is used to parse the user request and obtain the target function corresponding to the user request;

[0044] The calling module is used to call at least one target intelligent agent unit matching the target function from the intelligent agent unit set based on the target function. Each intelligent agent unit is configured with an independent storage space and vector space, and after being loaded, the intelligent agent unit can execute the intelligent agent function corresponding to its preset function.

[0045] A loading module is used to load the at least one target intelligent agent unit to execute the user request. Attached Figure Description

[0046] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only embodiments of this application. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0047] Figure 1 A flowchart illustrating an application method for an intelligent agent unit provided in an embodiment of this application;

[0048] Figure 2 A flowchart illustrating a method for determining a target intelligent agent unit provided in this application embodiment;

[0049] Figure 3 A flowchart illustrating a method for processing requests based on a target intelligent agent unit, provided as an embodiment of this application;

[0050] Figure 4 This application provides a schematic diagram of an intelligent agent system architecture corresponding to an application scenario.

[0051] Figure 5 This application provides a schematic diagram illustrating the message interaction of various modules in an intelligent agent system architecture.

[0052] Figure 6 This is a schematic diagram of the structure of an intelligent agent unit application device provided in an embodiment of this application. Detailed Implementation

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

[0054] The terms "first" and "second," etc., used in this application are used to distinguish different objects, not to describe a specific order. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units may include steps or units not listed, but may include steps or units not listed.

[0055] This application relates to the field of artificial intelligence technology, and mainly provides a method and apparatus for applying intelligent agent units. This method is primarily applied to intelligent agent systems requiring complex memory and multi-task processing capabilities, such as intelligent virtual assistants, personalized recommendation engines, and automated decision-making platforms. The method receives and parses user requests to determine their target functions, and then calls and executes a matching target intelligent agent unit from a set of intelligent agent units with independent storage and vector spaces. This achieves modular organization and on-demand scheduling of intelligent agent functions, effectively solving the problems of low collaboration efficiency and poor scalability caused by the lack of a unified standard for interaction among intelligent agent units (also known as memory units) in existing artificial intelligence (AI) systems. This improves the maintainability, functional reusability, and overall operational efficiency of intelligent agents.

[0056] In the field of artificial intelligence applications, an intelligent agent is a computer program capable of perceiving its environment, making decisions, and executing actions to achieve a specific goal. An intelligent agent can be a chatbot, a game AI model, or a system that automates business processes. The intelligent agent units described in the embodiments of this application are the core functional units constituting an intelligent agent. Each unit is a micro-intelligent agent capable of independent operation within a specific application domain or for a specific task (such as knowledge retrieval, sentiment analysis, or logical reasoning). They possess independent storage and vector spaces, ensuring data isolation and encapsulation of proprietary knowledge. These intelligent agent units can be dynamically loaded, invoked, and combined through a standardized interaction protocol to collaboratively complete complex user requests.

[0057] See Figure 1 The illustration shows a flowchart of an intelligent agent unit application method provided in an embodiment of this application. This intelligent agent unit application method is executed through an electronic device configured with an intelligent agent, wherein the electronic device may include a server, computer, mobile phone, or other device capable of loading an intelligent agent. The method may include the following steps:

[0058] S101, Receive user request.

[0059] S102. Parse the user request to obtain the target function corresponding to the user request.

[0060] S103. Based on the target function, call at least one target intelligent agent unit that matches the target function from the set of intelligent agent units.

[0061] S104. Load at least one target intelligent agent unit to execute the user request.

[0062] In step S101, a user request refers to a functional requirement initiated by a user to an intelligent agent through an electronic device (such as a laptop) configured with an intelligent agent or a terminal device (such as a mobile phone) communicating with the electronic device. This requirement can be expressed as a text command (such as calculating monthly sales data), a voice command, or a user interface command. For example, the electronic device can receive user requests through a preset communication interface and convert the request data into a structured data format that can be recognized by the intelligent agent processor (Agent Core) in the electronic device, so that it can perform subsequent analysis.

[0063] In step S102, the user request is parsed to obtain the target function corresponding to the user request. The target function refers to the specific business requirement corresponding to the user request, which is obtained by parsing the user request to extract the user's core intent and eliminate redundant information (such as interjections and irrelevant descriptions). For example, semantic analysis is performed on the text content of the user request to identify keywords, map them to a pre-set function library in the system, and determine the target function.

[0064] In step S103, a target intelligent agent unit can be determined based on the target function. The intelligent agent unit set includes multiple intelligent agent units, each configured with independent storage space and vector space. Once loaded, the intelligent agent unit can execute the intelligent agent function corresponding to its preset function. The independent storage space of the intelligent agent unit is used to store its exclusive business data, such as sales data tables and configuration parameters. The vector space of the intelligent agent unit is constructed based on a deep learning model and used for contextual reasoning, such as analyzing the priority of statistical dimensions. A mapping table between each intelligent agent unit and its function can be pre-constructed. After obtaining the target function, the target intelligent agent unit that matches the target function can be determined based on this mapping table. For example, if the target function is quarterly sales data statistics, the uniquely matched intelligent agent unit is the sales data statistics unit (represented as v1.0). This unit's storage space stores the raw sales data for each quarter of 2024, and its vector space integrates data filtering and statistical reasoning models. This allows for subsequent completion of quarterly sales data statistics based on this unit. For example, if the target function is to customize a company's product sales plan for the next quarter, this typically requires multi-dimensional analysis. Based on a function mapping table, three intelligent agent units that need to be invoked concurrently can be identified to work collaboratively. These three intelligent agent units can include a historical sales data analysis unit, a market competitor monitoring unit, and a user feedback information mining unit. Specifically, the historical sales data analysis unit stores detailed sales data for each quarter of previous years, and its vector space integrates trend prediction and factor analysis models to provide historical performance benchmarks and forecasting functions. The market competitor monitoring unit stores competitor product and price dynamics, and its vector space integrates semantic analysis and competitiveness assessment models to provide market environment analysis functions. The user feedback information mining unit stores user reviews and survey data, and its vector space integrates user intent and topic extraction models to identify user needs. By loading these multiple intelligent agent units, the system can collaboratively utilize their respective proprietary data and reasoning capabilities to comprehensively generate a relevant marketing strategy report. This collaborative decision-making based on multiple intelligent agent units improves the accuracy of data processing.

[0065] In step S104, after identifying the target intelligent agent unit, at least one target intelligent agent unit can be loaded. This includes loading the target intelligent agent unit's program code, configuration information, and storage space data into the electronic device's computing content, and activating the unit's preset functions. Then, these target intelligent agent units will complete information processing and output results based on their own functions and the parameter information corresponding to the user request.

[0066] For example, taking an intelligent agent data analysis system applied in an enterprise as an example, an employee (user) inputs a user request through the system interface, such as "statistics on sales data for Q2 2024". The system receiving module captures this request and transmits it to the parsing module. The parsing module identifies the core intent as quarterly sales data statistics, determines the target function and parameters (such as the time range: 2024-Q2), and calls the module to match the "Sales Data Statistics Unit (v1.0)" from the intelligent agent unit set. This unit's storage space stores the raw sales data from Q1-Q3 2024, and its vector space supports multi-dimensional statistical inference. Then, the unit is loaded, reads the Q2 2024 data, calculates sales revenue by different sales regions, generates data reports, and provides feedback to the employee. As another example, still using this application scenario, the user's need is to analyze the product line's sales performance in Q2 2024, predict the Q3 trend, and provide optimization suggestions. The processing system's parsing module will analyze this user's need and find that it is a comprehensive task, including historical statistics, trend prediction, and strategy generation functions. Then, based on the function mapping table, at least three target intelligent agent units that need to be called concurrently to work collaboratively are identified. These include the sales data statistics unit, the sales forecast analysis unit, and the business strategy suggestion unit. The sales data statistics unit is used to collect historical sales data for Q2; the sales forecast analysis unit, with its vector space integrated time series forecasting model, is responsible for predicting Q3 trends based on historical data; and the business strategy suggestion unit, with its vector space integrated attribution analysis and strategy generation model, is responsible for combining statistical and forecast results to generate optimization suggestions. The system loads these three units in parallel. After each unit executes its function, their outputs are integrated to generate a comprehensive analysis report containing data reports, forecast curves, and product sales suggestions. In this way, when faced with complex requests, the system can intelligently parse and determine the need for multiple units to coexist and work collaboratively. By calling multiple functionally complementary intelligent agent units, it can complete complex analysis tasks that a single unit cannot handle, improving processing efficiency and accuracy.

[0067] This application provides a method for applying intelligent agent units. The method parses a received user request to obtain the target function corresponding to the request; based on the target function, it calls at least one target intelligent agent unit matching the target function from a set of intelligent agent units; and then loads at least one target intelligent agent unit to execute the user request. By constructing a unified "parsing-calling-loading" interaction process and an intelligent agent unit architecture with independent storage space, it achieves precise scheduling and high collaboration of intelligent agent functions, solves the problems of high coupling and poor reusability of intelligent agent units in intelligent agent systems, and improves the flexibility, scalability, and task execution efficiency of intelligent agent applications.

[0068] The following describes the relevant technical features of the intelligent agent unit application method in the embodiments of this application, in conjunction with the corresponding application scenarios.

[0069] To achieve unified scheduling and application of intelligent agent units, this embodiment of the application can also accurately determine the target intelligent agent unit by matching the standard invocation message containing the operation type and unit identifier with the pre-configured metadata of each unit. Correspondingly, see [link to relevant documentation]. Figure 2 The diagram illustrates a method for determining a target intelligent agent unit according to an embodiment of this application. The process of calling at least one target intelligent agent unit matching the target function from a set of intelligent agent units based on the target processing function may include the following steps:

[0070] S201. Based on the target function, determine the target operation type.

[0071] S202. Generate the target invocation message based on the target operation type.

[0072] S203. Match the target invocation message with the pre-configured description fields of each intelligent agent in the intelligent agent set.

[0073] S204. Determine at least one intelligent agent unit whose matching result satisfies the matching condition as the target intelligent agent unit.

[0074] In step S201, the target operation type is at least one of the operation type set, which represents a set of operation instructions used to adjust the application state of the intelligent agent unit. Examples include LOAD, UNLOAD, SWITCH, and SYNC. The target operation type refers to the specific operation on the target intelligent agent unit determined according to the target function. For example, executing a statistical function requires first loading an intelligent agent unit with data statistical functions; therefore, the target operation type is LOAD.

[0075] In step S202, the target invocation message is an instruction carrier that conforms to a standard unified format. For example, the target invocation message includes a first field corresponding to the target operation type and a second field corresponding to the intelligent agent unit to be invoked. The second field can be the representation information of the intelligent agent unit to be invoked, such as unit_id (unit identifier), version (version number), fingerprint (digital fingerprint), context_hash (context hash value), timestamp (timestamp), signature (digital signature), payload (data payload), etc. If the generated target invocation message conforms to a preset transmission format (such as JSON-RPC or gRPC format), the target invocation message can be further encapsulated using a binary encapsulation method to improve transmission efficiency.

[0076] In step S203, the pre-configured description field of the agent unit represents metadata of the agent unit's attribute information. This includes all fields corresponding to the second field, representing the agent unit's identity and functional representation. For example, the second field in the target invocation message can be matched against the agent unit's description field, while simultaneously verifying whether the target operation type is in the target agent unit's supported operation type list. Further, the matching condition in step S204 means that the second field in the target invocation message matches the agent unit's description field, and the target operation type is in the agent unit's operation type list. If multiple agent units match the target invocation message, these agent units can be used simultaneously as target agent units, or the latest version of the agent unit can be selected as the target agent unit based on its version number and other information.

[0077] This embodiment achieves semantic invocation and pluggability of intelligent agent units by matching standardized invocation message formats with unit description fields. On the one hand, the unified field solves the problem of chaotic invocation formats in the prior art, and different intelligent agent units can be discovered and invoked based on the same rules. On the other hand, the description field, as the metadata of the intelligent agent unit, facilitates the system to manage unit attributes, supports version iteration and function expansion, and improves the accuracy and efficiency of intelligent agent unit invocation.

[0078] Taking the application scenario of preparing meeting materials through an intelligent agent as an example, a user requests the intelligent agent system to prepare a summary report on the latest development trends in technology field A. The electronic device carrying the intelligent agent first parses the user request and determines that its core objective is to prepare a report. Based on this, it determines that two core operations need to be performed: loading relevant knowledge and synchronizing the report state. Therefore, it determines the target operation types as "loading" and "state synchronization," and then generates target invocation messages, that is, generates standardized invocation messages for each operation type. For the "loading" operation, the generated message content can be: "Execute the loading operation, call the knowledge retrieval unit, the task is to retrieve relevant information on the latest development trends in technology field A." For the "state synchronization" operation, the generated message content can be: "Execute the state synchronization operation, call the document writing unit, the format requirements of the summary report need to be followed."

[0079] Then, these call messages are compared with the pre-defined description fields of all intelligent agent units in the system. For example, the description field of the knowledge retrieval unit in the intelligent agent unit set declares its function as "industry knowledge retrieval," and the supported operation types include "loading" and "querying." The description field of the document writing unit declares its function as "document writing and formatting," and the supported operation types include "state synchronization" and "generation." Through matching, the operation type "loading" in the "load-knowledge retrieval unit" instruction matches the "loading" operation supported by the knowledge retrieval unit, and the target unit identifier points to this unit. The operation type "state synchronization" in the "state synchronization-document writing unit" instruction matches the "state synchronization" operation supported by the document writing unit, and the target unit identifier executes this unit. Based on this, the system ultimately determines the knowledge retrieval unit and the document writing unit, two callable units with execution capabilities, as the target intelligent agent units for this task. This process, through matching standardized operation instructions with the self-declaration capabilities of the units, achieves precise positioning and invocation from user needs to specific executable functional units. The unique identifier of a unit (such as unit_id) points to a fully functional intelligent agent unit that combines a specific knowledge base with pre-defined processing logic, rather than a static dataset. In this way, the system decouples the logical abstraction and physical implementation of functional units at the invocation level, so that the discovery and scheduling of unit capabilities no longer depend on hard coding or static configuration, thereby significantly improving the modularity, functional reusability, and dynamic expansion capabilities of the intelligent agent system.

[0080] To further ensure the security of data processing, in this embodiment, security verification is performed on the operation request and the target unit before loading the target intelligent agent unit. Specifically, before loading the target intelligent agent unit, the method further includes: verifying the target intelligent agent unit based on the verification field carried in the target invocation message and the pre-configured digital fingerprint of the target intelligent agent unit; and loading the target intelligent agent unit in response to successful verification.

[0081] The verification field refers to the digital signature field in the target call message, which can be generated by encrypting the message content using a private key. The digital fingerprint refers to a field in the pre-configured description field of the target intelligent agent unit, calculated by the intelligent agent program code and configuration information using an encryption algorithm (such as SHA-256), used to uniquely identify the integrity of the unit. Specifically, the digital signature field can be decrypted using the public key in the electronic device system, and the decrypted message content can be compared with the original content of the target call message to determine if the message has been tampered with. Then, the digital fingerprint currently calculated by the target intelligent agent unit in real time is compared with its pre-configured digital fingerprint to determine if the target intelligent agent unit has been tampered with. The loading process of the target intelligent agent unit is only triggered when the above security verification conditions are met; if verification fails, the loading process is terminated and an error message is sent to the user (e.g., "Unit verification failed, request cannot be executed"). This embodiment implements identity verification and integrity checks for intelligent agent units, solving the problems of intelligent agent units being easily forged and call messages being easily tampered with.

[0082] For complex task scenarios requiring multi-agent unit collaboration, this application also provides a multi-agent unit collaborative processing method. In some implementations, calling at least one target agent matching the target function from a set of agent units based on the target function includes: determining multiple target agent units that need to be called concurrently based on the target function, so that the multiple target agent units can collaboratively process the user request. Correspondingly, loading at least one target agent unit to execute the user request processing process includes: determining the processing priority of multiple target agent units based on the task attributes corresponding to the user request; obtaining the processing results output by each target agent unit according to the processing priority; and integrating the processing results to generate an execution result corresponding to the user request.

[0083] Concurrent invocation refers to loading multiple intelligent agent units simultaneously, with each intelligent agent unit executing sub-tasks (jointly supporting the realization of the target function). Multiple target intelligent agent units can complement each other's functions, meaning that the combination of sub-tasks of each intelligent agent unit can fully realize the target function. For example, if the target function is to generate a sales analysis report for Q2 2024, the sales data statistics unit needs to calculate data, the market trend analysis unit needs to interpret data, and the report generation unit needs to format and output the report.

[0084] The task attributes corresponding to a user request refer to the dependencies, processing time, and importance of the subtasks of each intelligent agent unit (e.g., sales data statistics are a prerequisite for market trend analysis, so they have higher priority; report generation requires waiting for the results of the former two, so it has the lowest priority). The processing priority of the target intelligent agent unit can be represented by a level (e.g., P1 is the highest, P2 is the next highest, and P3 is the lowest) or a numerical value (e.g., 10, 8, 5), determined by the scheduler according to preset rules (e.g., priority based on dependencies, priority based on longer processing times). Then, the scheduler transmits the results to the lower priority units (as input data) according to priority order, and collects the final sub-results of all units. If a high-priority unit times out, the scheduler can trigger a retry or degradation strategy (e.g., using historical data as a substitute). Finally, the sub-results of each unit are merged into a unified output according to the target functional requirements, such as formatting data, analysis, and reports into a complete document.

[0085] For example, in a multi-source knowledge fusion intelligent question-answering system, a user request might be "planning a five-day family trip to a seaside city with a moderate budget, including child-friendly activities and cultural experiences." The processing system recognizes that this complex need involves multiple professional dimensions and requires collaborative planning by four intelligent agent units: a destination selection unit, an itinerary planning unit, a budget optimization unit, and a safety and convenience assessment unit. The destination selection unit recommends cities based on geographical features, seasonal suitability, and family-friendliness index; the itinerary planning unit designs daily activity schedules and time allocations; the budget optimization unit estimates costs and optimizes cost-effectiveness based on the user's budget level; and the safety and convenience assessment unit evaluates safety factors such as transportation convenience, surrounding resources, and child-friendly facilities. Based on the travel planning logic, processing priorities are determined (represented by P1 to P4 from highest to lowest). The destination selection unit has a priority of P1, meaning that cities must be selected before subsequent planning can proceed. The safety and convenience assessment unit has a priority of P2, evaluating feasibility based on the selected cities. The itinerary planning unit has a priority of P3 (designing specific itineraries based on city characteristics and safety assessments). The budget optimization unit has a priority of P4, optimizing costs based on the complete itinerary. Thus, destination selection with a priority of P1 is loaded first, based on multi-dimensional filtering: for example, input conditions such as coastal cities, family-friendly, and rich cultural resources, three candidate cities (codes C1, C2, and C3) are selected from the tourism database, and then the seasonal suitability score and a list of featured activities for each city are output. The P2 unit evaluates the three candidate cities in parallel: checking the child resource coverage of city C1 (85%), evaluating the public transportation convenience index of city C2 (excellent), verifying the beach safety level of city C3 (Grade A), and generating a comprehensive safety assessment report. The P3 unit selects the city with the highest comprehensive score based on the previous results. Design a five-day itinerary: Days 1-2 beach activities, Day 3 cultural site visit, Day 4 children's amusement park, Day 5 free time; 2-3 specific activities scheduled for each day. Final optimization in Unit P4: Set a daily cost range per person based on a "medium budget"; recommend the most cost-effective accommodation and dining combinations; provide optional upgrades and cost-saving suggestions.

[0086] During processing, exception handling and personalized adjustments can also be performed. If the budget unit detects that the trip cost exceeds the threshold by 20%, the trip adjustment unit is automatically triggered to rearrange the itinerary. When the user adds "accompanying elderly person", the system dynamically loads the safety assessment updated by the aging facility assessment unit. Finally, a complete travel plan is generated. In this application scenario, based on the multi-agent unit collaborative processing architecture, the system can accurately match the user's multi-dimensional constraints and generate a complete solution covering the entire chain of needs through multi-unit cross-validation and collaborative working mechanisms. At the same time, it has dynamic adaptability, can adjust the unit working parameters according to real-time feedback, and effectively control potential risks that are easily overlooked in traditional solutions with the help of professional assessment units. Ultimately, the agents can output comprehensive solutions that can be directly executed, like domain experts, rather than simply listing information, which significantly improves the completeness, reliability and practicality of handling complex problems.

[0087] In this embodiment, priority scheduling ensures that core constraints are satisfied first, avoiding conflicting or deviating outputs from multiple intelligent agents, thus generating more reliable results that better reflect the user's true intent. The execution order of multiple intelligent agents is clearly defined, reducing unnecessary parallel computation and resource contention, making the system's process clearer and its response faster when handling complex tasks. Based on the collaborative processing of multiple intelligent agents, the accuracy and efficiency of agent processing are improved.

[0088] In some embodiments of this application, the method further includes: in response to recognizing that the operation type field in the target invocation message is an extended operation type, invoking the extended processing logic corresponding to the extended operation type; wherein, the extended operation type includes at least one of emotion synchronization and instruction optimization, and the extended processing logic is provided by the extended function interface implemented in the target intelligent agent unit.

[0089] In this embodiment, extended operation types refer to newly reserved operation types in addition to basic operation types (such as loading, unloading, switching, etc.), including EMOTION_SYNC (emotion synchronization) and OPTIMIZE_CMD (instruction optimization), which can be added according to business needs. The extended processing logic is provided by the intelligent agent unit through a standardized extended function interface to ensure that new functions are plug-and-play.

[0090] Specifically, the processing system can target the operation type field in the message. When the field value is identified as a predefined extended operation type (such as emotion synchronization), the extended processing flow is triggered. Based on the extended operation type, the extended function interface in the target agent unit is located. The corresponding extended processing logic is called through the standardized interface, passing the necessary parameters and data payload to the extended processing module. At this time, the emotion analysis unit receives the emotion synchronization instruction through the extended interface and adjusts the agent's emotion expression mode in real time. The optimization processing unit receives optimization instructions through the extended interface and dynamically optimizes the execution logic.

[0091] Taking the intelligent customer service scenario as an example, the system recognizes that the user's dialogue contains a need for emotional soothing and generates a call message containing the "emotion synchronization" operation type. The sentiment analysis unit provides the emotion synchronization logic through the extended function interface. The system calls this logic to realize emotion synchronization processing such as voice tone adjustment, response speed optimization, and wording emotion enhancement, so that the intelligent customer service can better understand the user's intention and improve the accuracy of its information output.

[0092] In this embodiment, a standardized extension interface is used to support the rapid integration of new intelligent agent functions. The extension mechanism does not change the core architecture of the system, ensuring the stability of basic functions and reserving a standardized access scheme for possible new intelligent agent capabilities in the future.

[0093] This application also provides a method for processing requests based on a target intelligent agent unit, see [link to relevant documentation]. Figure 3 The processing method may include the following steps:

[0094] S301. Load the target intelligent agent unit, and filter out candidate data associated with the processing task corresponding to the user request from the data stored in the target intelligent agent unit.

[0095] Candidate data refers to data in the target intelligent agent unit's storage space that is related to the processing task requested by the user. For example, if the user's requested processing task is to process sales data statistics, the candidate data is data related to sales data. Data filtering can be completed based on task keywords using the intelligent agent unit's vector space, ensuring the relevance of data to the task. For example, loading the "Sales Data Statistics Unit (v1.0)" will store the following data in its storage space: Data 1 is the original sales data table for Q2 2024 (including region, product, and sales amount); Data 2 is the sales summary table for Q1 2024; Data 3 is the sales comparison table for Q2 2023; and Data 4 is the user profile data table. The intelligent agent unit's vector space identifies the processing task keywords "Q2 2024" and "sales data," filtering out Data 1 and Data 3 as candidate data (Data 2 has a mismatched time, and Data 4 is irrelevant in type).

[0096] S302. Determine the priority of candidate data usage based on the business priority and / or user intent of the target intelligent agent unit.

[0097] Business priority refers to the business value of data (e.g., the latest data has higher priority than historical comparison data, and raw data has higher priority than summarized data), which can be determined by combining data timestamps (the latest timestamp has higher priority) and data types (e.g., raw data, summarized data). User intent refers to the potential user needs analyzed based on user requests (e.g., if the user request includes "compared to the same period last year," then historical comparison data has higher priority).

[0098] For example, a user request only needs to compile sales data for Q2 2024 (without a comparison requirement). Business priority: Data 1 (raw data from Q2 2024, latest timestamp) is higher than Data 3 (comparative data from Q2 2023), therefore, Data 1 has a higher priority than Data 3. As another example, if a user request is to compile sales data for Q2 2024 and compare it to the same period last year, considering the user's intent (comparison requirement), the business priority is adjusted to: Data 1 (A), Data 3 (A) (both are core requirements); simultaneously, if Data 3's timestamp is "2024-06-30" (latest), and Data 3's is "2023-06-30", the timestamp does not affect the current priority (because the user explicitly needs a comparison).

[0099] S303. Determine the target data from the candidate data based on the usage priority.

[0100] The target data is the data used to perform the processing task. It is selected according to the priority of use, such as high-priority data being selected first. If multiple data have the same priority, they are further filtered according to data completeness and accuracy.

[0101] S304. Execute the user request using the target data.

[0102] The target intelligent agent unit calls its own functions (such as statistical models and analysis algorithms), completes calculations based on the target data, and outputs results. The result format must meet the user's requirements (such as tables, charts, and text).

[0103] In this embodiment, candidate data is filtered from the target intelligent agent unit storage based on task semantics. For example, when processing product pricing, the latest market price and historical cost data are extracted from the market intelligence unit and the historical cost unit, respectively. Subsequently, data priority is determined through multi-dimensional evaluation, taking into account factors such as business rule weights, user intent preferences, and data timeliness to form a quantitative decision-making basis.

[0104] This application also provides another implementation method: when multiple target intelligent agent units with similar functions exist, the system can prioritize unit-level screening. Specifically, the management module first selects the most suitable single target unit for the current task from the candidate unit set based on factors such as the performance indicators, resource status, and professional domain matching degree of each unit, and then calls the data and processing capabilities of that unit to execute the user request. This unit-priority scheduling strategy effectively avoids resource competition and result conflicts caused by multiple units operating in parallel. By accurately locating the optimal processing unit, it significantly improves the system's resource utilization efficiency while ensuring task execution quality.

[0105] In this application embodiment, it further includes: responding to an update of a user request, re-determining at least one target intelligent agent unit to be loaded based on the updated user request; and executing the updated user request based on the re-determined at least one target intelligent agent unit to be loaded.

[0106] In real-world applications, the continuous iteration of user needs triggers the dynamic loading mechanism of the intelligent agent system. When the user's dialogue shifts from product pricing analysis to supply chain cost optimization, the system automatically unloads the pricing analysis unit and loads the supply chain management unit. When the user adds a risk assessment request, the system further loads the risk prediction unit. This unit scheduling mechanism, based on semantic context changes, enables the intelligent agent system to dynamically adjust the application of intelligent agent units. This avoids the resource waste caused by continuously loading all intelligent agent units while ensuring the system's deep responsiveness to complex and continuous tasks, achieving an optimal balance between resource efficiency and task adaptability.

[0107] Specifically, a user request update refers to a user adding supplementary or demanding information to an existing request, triggering the system to re-parse and re-invoke. Then, based on the updated user request, the system redetermines the matching target intelligent agent unit, which may involve adding, replacing, or deleting corresponding intelligent agent units from the existing ones. For example, if a user's initial request in an intelligent office system is to organize employee attendance records for July 2024, the system loads the attendance data organization unit (v1.0) and outputs a tabular attendance table. If the user then updates their request, such as categorizing attendance records by department and generating a monthly attendance summary table, the system will re-parse the request. The attendance data organization unit (for categorization) is retained, and a new summary table generation unit (v1.2) is added (for generating the summary table). The attendance data organization unit first categorizes attendance records by department, and the results are transmitted to the summary table generation unit, which generates departmental attendance details and a monthly summary table, which are then returned to the user. This embodiment achieves rapid adaptation after a user requests an update by dynamically loading and adjusting the intelligent agent unit, avoiding the tedious operation of re-initiating the request for change; at the same time, the flexible unit retention and unloading strategy reduces resource waste and redundant calculations, and improves the system response speed.

[0108] In some embodiments of this application, loading the target intelligent agent unit to execute the user request further includes: inputting the context information of the user request into the target intelligent agent unit, reasoning about the context through the vector space of the target intelligent agent unit, and generating an execution result corresponding to the user request.

[0109] The context information of the user request refers to historical interaction data (such as previous user requests and historical system responses) and environmental data (such as user characteristic information and current time) related to the user request. This context information can be converted into a data format that the intelligent agent unit can recognize, such as converting it into vector data and transmitting it to the vector space of the target intelligent agent unit. The vector space of the target intelligent agent unit is the inference environment built by its built-in deep learning model, which can perform semantic analysis and relational inference on the context information. Then, based on its inference results, the execution result is generated. That is, the target intelligent agent unit combines the context inference results with its stored target data and outputs an optimized result as the execution result. This embodiment realizes the ability to understand the user's potential needs through context inference in the vector space of the intelligent agent unit, solving the mechanical problem that the intelligent agent unit can only execute according to the literal request, and improving the accuracy of intelligent agent data processing.

[0110] This application embodiment also achieves dynamic optimization of system resources by establishing an intelligent agent unit lifecycle monitoring mechanism. In some embodiments, the method further includes: monitoring the lifecycle state of each target intelligent agent unit; and unloading the target intelligent agent unit in response to the target intelligent agent unit's lifecycle state meeting the unloading condition.

[0111] The lifecycle state of an intelligent agent unit refers to its operational status from loading to unloading, including running (executing tasks), idle (waiting for new instructions after task completion), and abnormal (running errors). For example, a lifecycle management module in an electronic device can determine the lifecycle state of an intelligent agent unit by monitoring metrics, including: idle time (e.g., the duration of time a task has been completed without being invoked), task completion amount (e.g., the number of tasks executed), invocation count (e.g., the total number of times the system has invoked the system), or resource utilization (e.g., memory and processor usage). Then, it is determined whether its lifecycle state meets the unloading conditions, which are preset resource release conditions, such as: idle time threshold (e.g., more than 300 seconds of idle time), task completion amount threshold (e.g., after completing a preset number of tasks), resource utilization threshold (e.g., memory usage exceeding 1GB and no new tasks), and user-initiated triggering (e.g., the user closing a request window). Unloading a target intelligent agent unit can release the memory and processor resources of the electronic device occupied by the target intelligent agent unit, such as removing the target intelligent agent unit from the running memory. In this embodiment, by establishing an automated resource reclamation mechanism, the system can continuously monitor the resource occupancy and activity status of each intelligent agent unit, and immediately release the corresponding resources when it detects idle timeout, task completion or resource shortage, thereby significantly improving the system's resource utilization efficiency and overall stability, and effectively avoiding memory leaks and resource waste caused by the continuous residence of intelligent agent units.

[0112] Based on the description of the foregoing embodiments, in this application embodiment, the independent storage and vector space of each intelligent agent unit can achieve data and context isolation through a hierarchical isolation mechanism, ensuring that data cross-contamination does not occur when multiple units process in parallel. Simultaneously, the system is designed with a standardized hot-swappable interface and a dynamic scheduling framework, supporting lossless replacement and task switching of intelligent agent units during runtime, thereby achieving flexible functional expansion and dynamic reconfiguration while ensuring system stability.

[0113] Based on the foregoing embodiments, this application further provides a general implementation scheme for data isolation between intelligent agent units. This scheme establishes a multi-level isolation system to ensure the logical and physical independence of the storage space, computing environment, and context data of each intelligent agent unit, thereby achieving data security and isolation guarantees at the system level when multiple units work in parallel. Specifically, the physical isolation of the storage space of intelligent agent units can be achieved by assigning each intelligent agent unit a unique storage identifier upon system registration, and the system creating an independent storage partition based on this identifier. For example, the sales data analysis unit is assigned the storage identifier "SALES_MOD_001," and all its data files are stored in the first directory, which has an independent access control list. The customer service record unit's data is stored in a completely isolated database partition, such as 001. Data access between intelligent agent units requires a standardized data exchange interface; no unit can directly access the original storage space of other units. Correspondingly, the vector space operation of the intelligent agent unit is isolated, and the vector computation environment of each intelligent agent unit runs in an independent container: the system uses containerization technology to create an isolated runtime environment for each loaded unit. For example, an independent container containing tensor flow runtime is created for the image recognition unit. The memory space of each container is limited and isolated through a control group to ensure that intermediate data during model computation is not leaked to other units. The model parameter file of the vector space is stored in unit-specific encrypted form and is decrypted to the protected memory area only when the unit is loaded. In the embodiments of this application, the intelligent agent unit also includes a context session isolation mechanism. The system creates a unique session context identifier for each user request. This identifier runs through the entire processing flow. For example, when user A initiates a request, the system generates a session identifier "U01". When the user preference unit processes the request, its internal logic first verifies the session identifier of the input data and only processes requests that match the identifier. The unit sets up a session-level data cache. Data from different sessions is physically isolated at the cache layer. All intermediate data output by the unit carries the original session identifier to ensure that session confusion does not occur during data transmission.

[0114] Taking the simultaneous processing of inquiries from users A and B as an example, user A's inquiry description is labeled UA, and user B's description is labeled UB. During processing, the data analysis unit internally sets up two completely independent data processing pipelines. The unit's memory buffer is divided into two independent areas, A and B, and the processing results are stored in their respective output buffers. Even if two requests arrive simultaneously, the agent unit's scheduler ensures that the processing logic maintains strict session isolation during time-slice rotations.

[0115] Based on the foregoing embodiments, this application also provides a general architecture scheme supporting hot-swapping of intelligent agent units and dynamic task switching. By defining standardized unit interfaces, designing a centralized unit manager, and establishing state transition and resource coordination mechanisms, the intelligent agent system can seamlessly replace, load, or unload functional units at runtime, and dynamically reorganize working units according to task changes, thereby ensuring service continuity while achieving elastic expansion and flexible adjustment of system functions. The implementation details of this architecture will be described in detail below. To achieve runtime replacement and dynamic task switching of intelligent agent units, a hot-swappable architecture can be used. A corresponding standard interface can be set for each intelligent agent unit, a set of standardized lifecycle management interfaces, including initialize(), activate(context)(), deactivate(), and terminate(). The system uses a unit manager to uniformly maintain the loading state of all units. For example, when it is necessary to replace the "Travel Planning Unit" with the upgraded "Travel Planning Unit v2.0" during operation, the unit manager first sends a deactivate() instruction to the old unit, which saves its current state and enters silent mode. Then, a terminate() instruction is sent to release all its resources. The unit manager loads the new version of the unit file, calls its `initialize()` interface to initialize it, and injects the saved context state. All subsequent related requests are then routed to the new unit. This process is transparent to upper-layer applications and users, ensuring uninterrupted business updates.

[0116] Correspondingly, in this embodiment, dynamic task scenario switching can also be achieved by switching and coordinating corresponding intelligent agent units. For example, when the user's dialogue changes from "help me plan a trip" to "recommend some books for me," after the system parses the new intent, the scheduler will immediately decide: suspend or suspend the task of the current "trip planning unit" (calling its deactivate() to save the intermediate state). The "book recommendation unit" is loaded in parallel to process the new book recommendation request. After the book recommendation is completed, the user can choose to resume the trip planning task or clear its resources according to the user's instructions. This switching is automatically completed by the scheduler based on resource policies and task priorities, demonstrating the system's flexibility in dealing with complex and ever-changing dialogue flows.

[0117] See Figure 4 This illustrates a schematic diagram of an intelligent agent system architecture corresponding to an application scenario provided in an embodiment of this application. Figure 4The core processing module of the intelligent agent is used to receive and process user requests. A collection of intelligent agent units, consisting of multiple intelligent agent units, serves as the functional module for the operation of the intelligent agent, and is connected to the core processing module through a unified protocol layer. The scheduling module coordinates the parallel processing of multiple intelligent agent units and resolves conflicts. The encryption module provides security verification for all interactions, ensuring the security of data exchange.

[0118] In this scenario, the core processing module of the intelligent agent can issue instructions through a standardized protocol layer. For example, when the agent needs to access knowledge, it sends a standardized message to the protocol layer, such as a loading message for the agent unit. The scheduler receives this message and routes it to the most suitable target agent unit for loading operation based on priority and other strategies. The entire process is signed and verified by an encryption module, ensuring the security and integrity of communication. This architecture enables modularity, pluggability, and secure collaboration of intelligent agent units.

[0119] See Figure 5 This diagram illustrates the message interaction between various modules in an intelligent agent system architecture provided in this application. When the intelligent agent system needs to call an intelligent agent unit, the core processing module first generates a structured interaction message containing the operation type (e.g., "load"), the target intelligent agent unit's identification information, necessary payload data, and a security verification field. This message is passed to the protocol layer, processed by the encryption module, and then passed to the processing module for security verification. Once verification is successful, the core processing module returns a successful verification message to the scheduling module and executes the loading operation. Next, if the core processing module generates a new switching message, the scheduling module, based on its built-in switching logic, triggers the unloading of the original intelligent agent unit and simultaneously loads the newly specified intelligent agent unit. During this process, the scheduling module also feeds back the target unit's identification information to the relevant modules and may expand the message to include emotional state synchronization content, thereby achieving synchronized switching of emotional states between the old and new intelligent agent units, ultimately completing the smooth replacement and state continuation of the entire intelligent agent unit. This embodiment ensures the safety, reliability, efficiency, and smoothness of the intelligent agent unit switching process. Furthermore, through the synchronization function of emotional states, it maintains the continuity and naturalness of the user experience during the switching, thereby improving the user experience.

[0120] See Figure 6 This application also provides an intelligent agent unit application device, including:

[0121] Receiver module 601 is used to receive user requests;

[0122] The parsing module 602 is used to parse the user request and obtain the target function corresponding to the user request;

[0123] The calling module 603 is used to call at least one target intelligent agent unit matching the target function from the intelligent agent unit set based on the target function. Each intelligent agent unit is configured with an independent storage space and vector space, and after the intelligent agent unit is loaded, it can execute the intelligent agent function corresponding to its preset function.

[0124] Loading module 604 is used to load the at least one target intelligent agent unit to execute the user request.

[0125] In some implementations, the calling module includes:

[0126] The first determining submodule is used to determine the target operation type based on the target function; wherein the target operation type is at least one of the operation type set, and the operation type set represents a set of operation instructions used to adjust the application state of the agent unit;

[0127] The first generation submodule is used to generate a target invocation message based on the target operation type. The target invocation message includes a first field corresponding to the target operation type and a second field of the intelligent agent unit to be invoked corresponding to the target operation type.

[0128] The matching submodule is used to match the target call message with the pre-configured description fields of each intelligent agent unit in the intelligent agent unit set; the pre-configured description fields of the intelligent agent units represent metadata of the attribute information of the intelligent agent units;

[0129] The second determining submodule is used to determine at least one intelligent agent unit whose matching result satisfies the matching condition as the target intelligent agent unit.

[0130] In some embodiments, the device further includes, prior to loading the target agent unit:

[0131] The security verification module is used to verify the target intelligent agent unit based on the verification field carried in the target invocation message and the digital fingerprint pre-configured in the target intelligent agent unit; and to load the target intelligent agent unit in response to the successful verification of the target intelligent agent unit.

[0132] In some implementations, the calling module is further configured to:

[0133] Based on the target function, multiple target intelligent agent units that need to be called concurrently are identified, so that the multiple target intelligent agent units can collaboratively process the user request.

[0134] Loading the at least one target intelligent agent unit to execute the user request includes:

[0135] Based on the task attributes corresponding to the user request, the processing priority of the at least one target intelligent agent unit is determined;

[0136] According to the processing priority, the processing results output by each target intelligent agent unit are obtained;

[0137] The processing results are integrated to generate an execution result corresponding to the user request.

[0138] In some implementations, the loading module includes:

[0139] A loading submodule is used to load the at least one target intelligent agent unit and filter candidate data associated with the processing task corresponding to the user request from the data stored in the target intelligent agent unit.

[0140] The third determining submodule is used to determine the usage priority of the candidate data based on the business priority and / or user intent of the target intelligent agent unit;

[0141] The fourth determining submodule is used to determine the target data from the candidate data according to the usage priority;

[0142] The first execution submodule is used to execute the user request using the target data.

[0143] In some embodiments, the device further includes:

[0144] A re-determination module is used to re-determine at least one target intelligent agent unit to be loaded based on the updated user request in response to the update of the user request.

[0145] The re-execution module is used to execute the updated user request based on at least one target intelligent agent unit to be re-determined for loading.

[0146] In some implementations, the loading module is further configured to:

[0147] The context information of the user request is input into the target intelligent agent unit;

[0148] The context is reasoned through the vector space of the target intelligent agent unit to generate an execution result corresponding to the user request.

[0149] In some embodiments, the apparatus further includes:

[0150] A monitoring module is used to monitor the lifecycle state of each target intelligent agent unit; in response to the lifecycle state of the target intelligent agent unit meeting the unloading condition, the target intelligent agent unit is unloaded.

[0151] In some embodiments, the apparatus further includes:

[0152] The extended invocation module is used to invoke the extended processing logic corresponding to the extended operation type in response to the recognition that the operation type field in the target invocation message is an extended operation type.

[0153] The extended operation type includes at least one of emotion synchronization and instruction optimization, and the extended processing logic is provided by the extended function interface implemented in the target intelligent agent unit.

[0154] It should be noted that the specific implementation of each module and sub-module in this embodiment can be referred to the corresponding content above, and will not be described in detail here.

[0155] In another embodiment of this application, a readable storage medium is also provided, on which a computer program is stored, which, when executed by a processor, implements the intelligent agent unit application method as described above.

[0156] In another embodiment of this application, an electronic device is also provided, which may include:

[0157] Memory, used to store applications and the data generated by the running of the applications;

[0158] A processor for executing the application to implement the intelligent agent unit application method as described.

[0159] It should be noted that the specific implementation of the processor in this embodiment can be referred to the corresponding content above, and will not be described in detail here.

[0160] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the apparatus disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the description is relatively simple; relevant parts can be referred to the method section.

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

[0162] The steps of the methods or algorithms described in conjunction with the embodiments disclosed herein can be implemented directly by hardware, a software module executed by a processor, or a combination of both. The software module can be located in random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other form of storage medium known in the art.

[0163] The above description of the disclosed embodiments enables those skilled in the art to make or use this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for applying an intelligent agent unit, comprising: Receive user requests; The user request is parsed to obtain the target function corresponding to the user request; Based on the target function, at least one target intelligent agent unit matching the target function is called from the intelligent agent unit set. Each intelligent agent unit is configured with an independent storage space and vector space, and after being loaded, the intelligent agent unit can execute the intelligent agent function corresponding to its preset function. Load the at least one target intelligent agent unit to execute the user request.

2. The method according to claim 1, wherein calling at least one target intelligent agent unit matching the target function from the set of intelligent agent units based on the target function comprises: Based on the target function, a target operation type is determined; wherein, the target operation type is at least one of the operation type set, and the operation type set represents a set of operation instructions used to adjust the application state of the agent unit; Based on the target operation type, a target invocation message is generated, the target invocation message including a first field corresponding to the target operation type and a second field of the intelligent agent unit to be invoked corresponding to the target operation type; The target invocation message is matched with the pre-configured description fields of each intelligent agent unit in the intelligent agent unit set; the pre-configured description fields of the intelligent agent unit represent metadata of the attribute information of the intelligent agent unit. At least one intelligent agent unit whose matching result satisfies the matching condition is identified as the target intelligent agent unit.

3. The method according to claim 2, wherein before loading the target intelligent agent unit, the method further comprises: The target intelligent agent unit is verified based on the verification field carried in the target invocation message and the digital fingerprint pre-configured in the target intelligent agent unit. In response to the successful verification of the target intelligent agent unit, the target intelligent agent unit is loaded.

4. The method according to claim 1, wherein calling at least one target agent matching the target function from the set of agent units based on the target function comprises: Based on the target function, multiple target intelligent agent units that need to be called concurrently are identified, so that the multiple target intelligent agent units can collaboratively process the user request. Loading the at least one target intelligent agent unit to execute the user request includes: Based on the task attributes corresponding to the user request, the processing priority of the at least one target intelligent agent unit is determined; According to the processing priority, the processing results output by each target intelligent agent unit are obtained; The processing results are integrated to generate an execution result corresponding to the user request.

5. The method according to claim 1, wherein loading the at least one target intelligent agent unit to execute the user request comprises: Load the at least one target intelligent agent unit, and filter candidate data associated with the processing task corresponding to the user request from the data stored in the target intelligent agent unit; The usage priority of the candidate data is determined based on the business priority and / or user intent of the target intelligent agent unit; Based on the usage priority, target data is determined from the candidate data; The user request is executed using the target data.

6. The method according to claim 1, further comprising: In response to the update of the user request, at least one target intelligent agent unit to be loaded is re-determined based on the updated user request; The updated user request is executed based on the re-determined target agent unit to be loaded.

7. The method according to claim 1, wherein loading the at least one target intelligent agent unit to execute the user request comprises: The context information of the user request is input into the at least one target intelligent agent unit; The context is reasoned through the vector space of the target intelligent agent unit to generate an execution result corresponding to the user request.

8. The method according to claim 1, further comprising: Monitor the lifecycle status of each target intelligent agent unit; When the lifecycle state of the target intelligent agent unit meets the unloading condition, the target intelligent agent unit is unloaded.

9. The method according to claim 2, further comprising: In response to the recognition that the operation type field in the target call message is an extended operation type, the extended processing logic corresponding to the extended operation type is invoked; The extended operation type includes at least one of emotion synchronization and instruction optimization, and the extended processing logic is provided by the extended function interface implemented in the target intelligent agent unit.

10. An intelligent agent unit application device, comprising: The receiving module is used to receive user requests; The parsing module is used to parse the user request and obtain the target function corresponding to the user request; The calling module is used to call at least one target intelligent agent unit matching the target function from the intelligent agent unit set based on the target function. Each intelligent agent unit is configured with an independent storage space and vector space, and after being loaded, the intelligent agent unit can execute the intelligent agent function corresponding to its preset function. A loading module is used to load the at least one target intelligent agent unit to execute the user request.

Images