Domain-level agent system construction method and system, and intelligent question answering method and system

Abstract

The present application relates to the technical field of natural language processing, and provides a domain-level agent system construction method and system and an intelligent question and answer method and system, which comprises: obtaining semanticized descriptions and labels of tools; in response to a tool set creation instruction, associating tools with the same label to obtain a tool set; in response to a learning instruction, a large model calls semanticized descriptions of tools with the same label to generate tool set information; in response to an agent role creation instruction, binding a plurality of tool sets to a created agent role; in response to a learning instruction, a large model calls the bound tool set information to generate agent role information; in response to an agent group creation instruction, binding a plurality of agent roles to a created agent group; and in response to a learning instruction, a large model calls the bound agent role information to generate agent group information. The task processing accuracy and stability are greatly improved.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of natural language processing, and particularly relates to a domain-level intelligent agent system construction method and system and an intelligent question answering method and system. BACKGROUND

[0002] The statements in this section merely provide background information related to the present application and do not necessarily constitute prior art.

[0003] In the field of artificial intelligence, large model intelligent agent technology has evolved from a simple rule engine to a complex system with perception, understanding, decision-making and execution capabilities. With the continuous improvement of large language model (LLM) capabilities, especially in the breakthroughs in complex task decomposition and tool usage, intelligent agents can complete the entire process of work from information query to complex task execution.

[0004] Although general large model intelligent agents have strong language generation capabilities, they have problems with insufficient domain knowledge when facing complex tasks in specific fields such as medical diagnosis, financial risk control and industrial internet. This is because the training data of general models covers a wide range but lacks domain specificity, and the understanding accuracy of specialized terminology, logical rules and deep requirements in subfields is low. For example, for complex tasks such as water plant pump group maintenance, general intelligent agents have difficulty accurately decomposing the task into: first, assessing the health, capacity and security of each pump group, and then calling a scheduling optimization algorithm to provide recommendations.

[0005] The current mainstream intelligent agent construction method is to create a general intelligent agent, write a description and prompt words, bind a series of tools to the intelligent agent, and then start using it. When encountering complex problems, the task steps are decomposed by the knowledge of the general large model itself.

[0006] The general intelligent agent construction mode, i.e., the intelligent agent selection tool mode, is not suitable for domain intelligent agent construction:

[0007] Firstly, in some intelligent agent systems built on LLM, the intelligent agent autonomously selects and calls from a series of tools according to its own algorithm and understanding of the task, such as by comparing the matching degree of tool descriptions and task requirement keywords to select. This approach lacks strong constraints and is prone to tool calling chaos, with high error rates in complex task scenarios. In addition, relying on the large language model to understand natural language descriptions of tasks and generate decomposition steps, due to the insufficient understanding of complex tasks by the large language model, often results in redundant, missing or incorrect order of steps, leading to low efficiency of task execution and low success rate of completing complex tasks.

[0008] Secondly, when tools are exposed via MCP (Manufacturing Communication Protocol) or described via function calls, the lack of descriptions of results and usage instructions (such as the tool's use cases) makes it impossible for large models to provide the correct tool call selection and call parameters. Summary of the Invention

[0009] To address the technical problems mentioned above, this invention provides a method and system for constructing a domain-level intelligent agent system, as well as an intelligent question-answering method and system. It pioneers a four-layer progressive construction framework: tools, toolsets, intelligent agent roles, and intelligent agent role groups. This framework learns the execution steps of complex tasks into intelligent agent groups, eliminating the need for users to manually create execution steps. Only fine-tuning of the learned execution steps is required. Private domain knowledge is embedded into the core elements of each layer. This structured design transforms previously scattered private domain knowledge into executable constraint logic, avoiding the problems of chaotic tool binding and conflicting intelligent agent functions in unstructured systems. Tool invocation error rates are significantly reduced, greatly improving the accuracy and stability of task processing.

[0010] To achieve the above objectives, the present invention adopts the following technical solution:

[0011] The first aspect of this invention provides a method for constructing a domain-level intelligent agent system, comprising:

[0012] Obtain semantic descriptions and tags for the tools and store them in a graph database;

[0013] In response to the toolset creation command, tools with the same label are associated to obtain a toolset; in response to the learning command, the large model calls the semantic description of the tools with the same label to generate toolset information; the toolset and tools are bound and stored in the graph database;

[0014] In response to the agent role creation command, several toolkits are bound to the created agent role; in response to the learning command, the large model calls the bound toolkit information to generate agent role information; the agent role and toolkit are bound and stored in the graph database;

[0015] In response to the agent group creation command, several agent roles are bound to the created agent group; in response to the learning command, the large model calls the bound agent role information to generate agent group information; and the agent roles and agent groups are bound and stored in the graph database.

[0016] Furthermore, it also includes: calculating the relevance of each semantic description, and reminding technical personnel to make corrections when the average relevance of a semantic description to the other semantic descriptions is lower than a threshold.

[0017] Furthermore, the relevance is:

[0018] ;

[0019] in, Let i be the TF-IDF vector of the i-th semantic description. Let j be the TF-IDF vector of the j-th semantic description, and let length bias factor be the length bias factor. ; For smoothing term; adjustment factor ; λ 0 is the basic adjustment factor; entropy value M is the number of semantic descriptions, and the probability value is... Maximum entropy , N i This represents the total number of words in the i-th semantic description.

[0020] Furthermore, the toolset information, agent role information, and agent group information all include functions, objectives, and invocation steps.

[0021] Furthermore, the semantic description includes the tool's functions, input parameters, output result format, output semantics, and applicable scenarios.

[0022] Furthermore, the learning is triggered either upon creation or when the associated object is updated.

[0023] A second aspect of the present invention provides a domain-level intelligent agent system construction system, comprising:

[0024] The data acquisition module is configured to acquire semantic descriptions and labels of the tools and store them in the graph database.

[0025] The toolset creation module is configured to: in response to a toolset creation command, associate tools with the same label to obtain a toolset; in response to a learning command, the large model calls the semantic descriptions of tools with the same label to generate toolset information; and bind the toolset and tools to the graph database.

[0026] The role creation module is configured to: in response to an agent role creation command, bind several toolsets to the created agent role; in response to a learning command, the large model calls the bound toolset information to generate agent role information; and bind the agent role and toolsets to the graph database.

[0027] The agent group creation module is configured to: in response to an agent group creation command, bind several agent roles to the created agent group; in response to a learning command, the large model calls the bound agent role information to generate agent group information; and bind the agent roles and agent groups to the graph database.

[0028] A third aspect of the present invention provides an intelligent question-answering method, which, based on a domain-level intelligent agent system constructed using the domain-level intelligent agent system construction method described in the first aspect, comprises:

[0029] The input question is obtained, the large model performs intent recognition, and matches the intelligent agent group;

[0030] Retrieve information from the matched agent groups, combine it with the input question, and use a large model to assign agent groups and generate instantiation processes. Based on the instantiation processes, assign agent roles, toolsets, and tools in sequence, and generate results.

[0031] Furthermore, the result generation process is based on a reasoning-action pattern.

[0032] A fourth aspect of the present invention provides an intelligent question-answering system, comprising:

[0033] As described above, a domain-level intelligent agent system construction system, and

[0034] The intent recognition module is configured to: acquire the input question, perform intent recognition on the large model, and match the intelligent agent group.

[0035] The results generation module is configured to: retrieve the information of the matched agent group, combine it with the input question, allocate agent groups through a large model, and generate an instantiation process; based on the instantiation process, allocate agent roles, toolsets, and tools in sequence, and generate results.

[0036] Compared with the prior art, the beneficial effects of the present invention are:

[0037] This invention pioneers a four-layer progressive construction framework: tools, toolsets, agent roles, and agent role groups. It learns the execution steps of complex tasks into agent groups, eliminating the need for users to manually create execution steps. Users only need to fine-tune the learned execution steps. By embedding private domain knowledge into the core elements of each layer, this structured design transforms the originally scattered private domain knowledge into executable constraint logic. This avoids the problems of chaotic tool binding and conflicting agent functions in unregulated systems, greatly reducing the error rate of tool invocation and significantly improving the accuracy and stability of task processing.

[0038] This invention adds a "semantic description of results" structure field, which breaks down the tool description into function, input parameters, output result format, semantic output, and applicable scenarios, thereby enabling the tool's returned results to be associated with the task objectives.

[0039] This invention calculates the relevance of each semantic description. When the average relevance of a semantic description to the others is below a threshold, it alerts technicians to make corrections, thus preventing technicians from inputting incorrect semantic descriptions. Furthermore, to address the issue of significant length differences among different semantic descriptions, a length deviation factor is used to amplify these differences, assisting in identifying semantic descriptions that are structurally incompatible but semantically similar. Moreover, the influence of entropy is incorporated; the smaller the entropy, the more uneven the distribution of sentence lengths. In this case, the length deviation factor is larger, further increasing the impact of length deviation on similarity calculation when sentence lengths are unevenly distributed. Attached Figure Description

[0040] The accompanying drawings, which form part of this invention, are used to provide a further understanding of the invention. The illustrative embodiments of the invention and their descriptions are used to explain the invention and do not constitute an improper limitation of the invention.

[0041] Figure 1 This is a flowchart of a method for constructing a domain-level intelligent agent system according to Embodiment 1 of the present invention;

[0042] Figure 2 This is a flowchart of an intelligent question-answering method according to Embodiment 3 of the present invention. Detailed Implementation

[0043] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings.

[0044] It should be noted that the following detailed description is illustrative and intended to provide further explanation of the invention. Unless otherwise specified, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains.

[0045] Example 1

[0046] This embodiment provides a method for constructing a domain-level intelligent agent system.

[0047] This embodiment provides a domain-level intelligent agent system construction method. Through a dual mechanism of structured construction process and deep integration of private domain knowledge, it improves the accuracy of intelligent agents in handling complex problems in the domain. It mainly solves the core problems in complex task processing, such as chaotic tool calls, inaccurate task decomposition, and inefficient React process caused by lack of constraints.

[0048] This embodiment provides a method for constructing a domain-level intelligent agent system, which pioneers a four-layer progressive construction framework of tools, toolsets, intelligent agent roles, and intelligent agent role groups. This framework learns the execution steps of complex tasks into intelligent agent groups, eliminating the need for users to manually create execution steps. Instead, users only need to fine-tune the learned execution steps. This is equivalent to informing the larger model of private domain knowledge and a series of steps, embedding private domain knowledge (such as domain-specific rules, task logic, tool relationships, etc.) into the core elements of each layer. This structured design transforms the originally scattered private domain knowledge into executable constraint logic, avoiding the problems of chaotic tool binding and conflicting intelligent agent functions in ruleless systems.

[0049] This embodiment provides a method for constructing a domain-level intelligent agent system. By establishing a strong binding relationship between toolsets and intelligent agent roles, it fundamentally solves the problem of chaotic tool invocation. The toolset pre-combines specific tools based on domain knowledge and task logic and defines invocation rules. Intelligent agent roles can only call tools within the bound toolset and follow a preset order. This greatly reduces the error rate of tool invocation and significantly improves the accuracy and stability of task processing.

[0050] This embodiment provides a method for constructing a domain-level intelligent agent system. By integrating private domain knowledge into the construction of basic data for the intelligent agent system, tools and steps for dealing with problems in the domain are written into the basic data and then used as knowledge participation prompts in the knowledge graph. This allows the large model to fully understand the private domain knowledge, improves the accuracy of providing reasonable steps for complex problems, and increases the success rate of selecting and calling tools.

[0051] This embodiment provides a method for constructing a domain-level intelligent agent system, such as... Figure 1 As shown, it includes the following steps:

[0052] Step 1: Tool layer construction.

[0053] Step 101: Technical staff develop basic tools. When a new basic tool is released, the technical staff will add detailed semantic descriptions to the tool, including the tool's functions, input parameters, output result format, output semantics, applicable scenarios, etc.

[0054] For example, for a tool for obtaining device attribute information: the tool's functions (such as "get device attribute list information"), input parameters (such as device code), output result format (such as device attribute list information in JSON array format), semantic output (this tool returns the xx device attribute list information, the result is as follows:, each field is translated as:), and applicable scenarios (such as when obtaining device attribute data, if the user passes in the attribute name, it is necessary to call this tool or the mapping relationship between device attribute code and name).

[0055] For example, for a normalization tool: the tool's function (e.g., "normalize the input data"), input parameters (e.g., data after outlier correction), output result format (e.g., normalized data in JSON array format), semantic output (this tool returns data after normalizing the input parameters, as shown below), and applicable scenarios (e.g., if the user inputs data after outlier correction during normalization, this tool needs to be called).

[0056] Step 102: Calculate the relevance of each semantic description. When the average relevance of a semantic description (e.g., input parameter) to the other semantic descriptions is lower than the threshold, remind the technician to make corrections, thereby avoiding the technician from entering incorrect semantic descriptions.

[0057] The specific steps for calculating relevance are as follows:

[0058] (1) Word segmentation: Each sentence (i.e., semantic description) is segmented into words to obtain a word set:

[0059] The word segmentation result of the i-th semantic description: (m is the number of words in the i-th semantic description);

[0060] Constructing a global vocabulary: Merge the word segmentation results of all statements (5 semantic descriptions), and obtain a globally unique vocabulary after deduplication. , where k is the total number of unique words in the vocabulary, and the vector dimension of all subsequent statements is k.

[0061] (2) Calculate word frequency (TF).

[0062] For any word in word list V v t (t=1,2,...,k), its original word frequency in statement A TF i,t Defined as: ;in count ( v t , i ) indicates words v t The number of times it appears in the i-th semantic description.

[0063] Total number of words in the i-th semantic description: ; the i-th semantic description word v t Normalized TF: .

[0064] (3) Calculate the inverse document frequency (IDF).

[0065] For words in vocabulary Vv t Its IDF value formula is: Where |D| is the total number of statements (in this embodiment, due to the five semantic descriptions of tool function, input parameters, output result format, output semantics, and applicable scenarios, |D|=5); DF t Indicates the inclusion word v t The number of statements.

[0066] (4) Calculate the TF-IDF vector.

[0067] The i-th semantic description word v t TF-IDF value: ;

[0068] The TF-IDF vector of the i-th semantic description: .

[0069] (5) Calculate the cosine similarity between each pair of statements (the i-th semantic description and the j-th semantic description): ;in, Let i be the TF-IDF vector of the i-th semantic description. Let j be the TF-IDF vector of the j-th semantic description, and let length bias factor be the length bias factor. ; For smoothing term; adjustment factor ; λ 0 is the basic adjustment factor; the entropy value H measures the uniformity of the length distribution. M is the number of semantic descriptions (5 in this embodiment). Maximum entropy , N j This represents the total number of words in the j-th semantic description. Since the lengths of different semantic descriptions vary significantly (e.g., output format and applicable scenarios), and sentence lengths implicitly represent structural differences, a length deviation factor amplifies these differences, aiding in the identification of semantic descriptions that are structurally incompatible but semantically similar. Furthermore, the influence of entropy is incorporated; the smaller the entropy, the more uneven the sentence length distribution. In this case, the length deviation factor is larger, further increasing the impact of length deviation on similarity calculation when sentence length distribution is uneven.

[0070] (6) The distribution disorder of global statement length is quantified by entropy value H. The higher H is, the more uniform the length distribution is, and the smaller λ is. This weakens length enhancement and avoids excessive interference of semantics due to length differences when the length distribution of different semantic descriptions is uniform.

[0071] Step 103: When a tool is published, it will be associated with a tag to match the toolset.

[0072] The tags here can be data acquisition, data preprocessing, fault detection, etc.

[0073] These semantic descriptions and labels, along with other tool information, are stored in a graph database, providing the foundation for the generation of the upper toolset layer. At this stage, the nodes in the graph database are tool IDs and labels, with no associations or edges.

[0074] Step 2: Toolset layer construction.

[0075] Step 201: In response to the toolset creation command, associate tools with the same label to obtain a toolset.

[0076] Step 202: In response to the learning instruction, the large model calls the semantic description of the same-label tool and generates toolset information.

[0077] There are two opportunities to learn the toolset: (1) When the toolset is created, you can click the “Learn” button to learn it; (2) When you receive a signal that a new tool has been released, you will be prompted to click the “Learn” button to learn it.

[0078] The toolset information includes functions, objectives, and the order (steps) in which tools are invoked.

[0079] When learning (i.e., when generating a description of a toolset), the large model combines the functions of tools with the same tags to clarify the overall function of the toolset; when generating goals, the large model sets the goals of the toolset according to the needs of the subdivided task scenarios; when generating execution steps, the large model determines the calling order of each tool in the toolset based on the calling logic and order of the basic tools.

[0080] Once generated, users can edit and modify the toolset's description, objectives, and execution steps to adapt it to actual business needs.

[0081] For example, a data preprocessing toolset is designed to preprocess raw data. Its goal is to perform outlier detection, outlier correction, and normalization. The tool call sequence is as follows: 1. Obtain data from [time period][device] as the raw data; 2. First, call the outlier detection tool to detect outliers in the raw data; 3. Call the outlier correction tool to correct outliers in the raw data, then call the normalization tool to normalize the data and output the normalized data.

[0082] Finally, the toolset and tools are bound and stored in the graph database. At this point, a new toolset ID is added to the node, and the relationship between the toolset ID and the tool ID is "containment". For example, toolset 1 contains tools A, B and C.

[0083] Step 3: Construct the agent role layer.

[0084] Step 301: In response to the agent role (hereinafter referred to as agent) creation command, bind several toolsets to the created agent role.

[0085] For example, for a newly created fault diagnosis intelligent agent, bind a data preprocessing toolset and a fault identification toolset.

[0086] Step 302: In response to the learning instruction, the large model calls the information of the bound toolset and generates agent role information.

[0087] Similar to toolsets, there are two learning opportunities for intelligent agent roles: (1) When an intelligent agent role is created, once its role is determined, it can bind to a toolset and then click the "Learn" button to learn; (2) When it receives a signal that the bound toolset has been updated, it will prompt the user to click the "Learn" button to learn.

[0088] The agent role information includes description, objective, and toolset execution steps.

[0089] During learning, the description of the agent role is generated based on the functionality of the toolset; the goal is determined according to the goals of the toolset; and the execution steps are formulated according to the execution steps of the toolset.

[0090] After generation, users can also edit and modify the description, goals, and execution steps of the intelligent agent role.

[0091] For example, for a newly created fault diagnosis agent, the function is to complete the fault diagnosis of xx equipment; the goal is to realize the fault diagnosis of the equipment based on the raw data, through data preprocessing and fault identification; the toolset execution steps are: 1. Obtain the data of [xx time period][xx equipment] as the raw data; 2. First call the data preprocessing toolset to preprocess the raw data; 3. Call the fault identification toolset to identify the fault based on the preprocessed data and give the fault cause and maintenance suggestions.

[0092] Finally, the agent role and toolset are bound and stored in the graph database. At this time, the node is given an agent role ID, and the relationship between the toolset ID and the agent role ID is "dependency". For example, agent role 1 depends on toolset 1 and 2.

[0093] Step 4: Construct the agent role group layer.

[0094] Step 401: In response to the agent role group (hereinafter referred to as agent group) creation command, bind several agent roles to the created agent role group.

[0095] For example, for newly created equipment operation and maintenance intelligent agent groups, bind fault diagnosis intelligent agent, health assessment intelligent agent, professional report intelligent agent, and time-lapse playback intelligent agent.

[0096] Step 402: In response to the learning instruction, the large model calls the information of the bound intelligent agent role, and the large model generates intelligent agent role group information.

[0097] The agent role group information includes function, goal, and agent role execution steps.

[0098] Similar to toolsets and agent roles, agent groups have two learning opportunities: (1) When an agent group is created, it determines its domain, binds an agent role, and then clicks the "Learn" button to learn; (2) When it receives a signal of updating the bound agent role, it prompts the user to click the "Learn" button to learn.

[0099] The description of the agent role group will combine the functions of each agent role to clarify the complex tasks it can handle; the goal will be set according to the requirements of the complex task; and the execution steps will be formulated based on the execution steps and collaborative logic of each agent role.

[0100] Users can edit and modify the description, objectives, and execution steps of intelligent agent role groups to meet the processing needs of different complex tasks.

[0101] For example, a newly created equipment operation and maintenance intelligent agent group has the function of performing operation and maintenance on equipment xx; the goal is to achieve equipment operation and maintenance based on raw data through fault diagnosis intelligent agents, health assessment intelligent agents, professional report intelligent agents, and time-lapse replay intelligent agents; the execution steps are as follows: 1. Call the time-lapse replay intelligent agent to use the time-lapse replay algorithm to trace back the data of the abnormal downtime period of [equipment xx]; 2. Call the equipment anomaly detection intelligent agent to perform equipment anomaly detection on the data of [equipment xx] during [time period]; 3. Call the equipment fault diagnosis intelligent agent to perform equipment fault diagnosis on the data of [equipment xx] during [time period], and provide fault causes and maintenance suggestions; 4. Call the health assessment intelligent agent to perform health assessment on [equipment xx] and predict subsequent operating trends; 5. Call the professional report intelligent agent to provide a detailed analysis report.

[0102] Finally, the agent roles and agent role groups are bound and stored in the graph database. At this time, the nodes are given new agent role group IDs. The relationship between the agent role ID and the agent role group ID is "containment". For example, agent role group A contains agent roles 1 and 2.

[0103] This embodiment provides a method for constructing a domain-level intelligent agent system. It focuses on the construction of domain-level intelligent agent systems and aims to solve the core problems of "insufficient knowledge, chaotic tool invocation, and inaccurate task decomposition" in the processing of complex tasks in specific domains by general intelligent agents. It realizes the dynamic construction and efficient operation of domain-level intelligent agent systems through the technical path of "four-layer architecture construction - private domain knowledge integration - optimization of MCP protocol - graph database storage and retrieval".

[0104] This embodiment provides a method for constructing a domain-level intelligent agent system. The system is built on a four-layer progressive framework of "tools-toolsets-intelligent agent roles-intelligent agent role groups". Each layer generates functions, goals and execution steps by combining a large model with private domain knowledge through a learning mechanism (triggered when the associated object is created / updated). Users can edit and optimize as needed.

[0105] This embodiment provides a method for constructing a domain-level intelligent agent system, which embeds domain private domain knowledge (such as exclusive rules, task logic, and tool association relationships) into the core elements of each layer of the four-layer architecture. For example, the tool layer is bound to domain terminology labels, and the intelligent agent role layer is embedded with scene execution standards, so that private domain knowledge is transformed into executable constraint logic.

[0106] This embodiment provides a method for constructing a domain-level intelligent agent system. To address the lack of semantic interpretation in the general MCP protocol, a new "semantic description of results" structure field is added. The tool description is broken down into functions, input parameters, output result format, output semantics, and applicable scenarios, thereby enabling the association and annotation between the tool's returned results and the task objectives.

[0107] This embodiment provides a method for constructing a domain-level intelligent agent system, which maps the four-layer architecture information and relationships into graph nodes and edges, stores them in a graph database (such as memgraph), and then combines them with a knowledge graph to achieve multi-hop association queries (such as intelligent agent group-intelligent agent role-toolset-tool link tracing), quickly retrieve private domain knowledge to construct accurate prompt words.

[0108] The domain-level intelligent agent system construction method provided in this embodiment has the core advantage of deeply coupling the structured integration of private domain knowledge with the dynamic construction of the intelligent agent system. This not only solves the chaos of tool and intelligent agent collaboration in unconstrained systems, but also achieves a leap in the accuracy of the entire process of large models from task decomposition to execution feedback through precise empowerment of domain knowledge. This provides a reusable technical paradigm for the intelligent processing of complex domain-level tasks.

[0109] This embodiment provides a domain-level intelligent agent system construction method that significantly improves the overall accuracy of large models in handling complex tasks: In the task decomposition stage, the intelligent agent group, relying on the pre-set task decomposition logic in the private domain knowledge, can decompose complex problems into sub-task chains with clear steps and responsibilities, avoiding the problems of redundant or missing decomposition steps in traditional systems; In the tool invocation stage, the intelligent agent role can accurately identify user intent through the tool application scenarios labeled by the private domain knowledge, greatly reducing the tool invocation error rate; In the React process, based on the task completion standards defined in the private domain knowledge, it can accurately determine whether the current step has achieved the goal, avoiding meaningless loop execution or premature termination, thus improving the efficiency of the React process by more than 40%.

[0110] Example 2

[0111] This embodiment provides a domain-level intelligent agent system construction system, which specifically includes:

[0112] The data acquisition module is configured to acquire semantic descriptions and labels of the tools and store them in the graph database.

[0113] The toolset creation module is configured to: in response to a toolset creation command, associate tools with the same label to obtain a toolset; in response to a learning command, the large model calls the semantic descriptions of tools with the same label to generate toolset information; and bind the toolset and tools to the graph database.

[0114] The role creation module is configured to: in response to an agent role creation command, bind several toolsets to the created agent role; in response to a learning command, the large model calls the bound toolset information to generate agent role information; and bind the agent role and toolsets to the graph database.

[0115] The agent group creation module is configured to: in response to an agent group creation command, bind several agent roles to the created agent group; in response to a learning command, the large model calls the bound agent role information to generate agent group information; and bind the agent roles and agent groups to the graph database.

[0116] It should be noted that each module in this embodiment corresponds one-to-one with each step in Embodiment 1, and their specific implementation processes are the same, so they will not be repeated here.

[0117] Example 3

[0118] This embodiment provides an intelligent question-answering method, such as... Figure 2 As shown, the domain-level intelligent agent system constructed based on the domain-level intelligent agent system construction method described in Embodiment 1 includes:

[0119] Step A: The user inputs a question. Once the question is received, the large model first performs intent recognition to identify which group of intelligent agents can solve the problem.

[0120] Suppose a user inputs the question: "Water pump No. 1 has experienced abnormal shutdowns in the past 3 days. Please analyze the cause and assess the subsequent operating trend." The large model intent in the domain intelligent agent system recognizes that this is a complex task that requires combining historical equipment operating data for fault analysis and risk assessment, and matches it to the "Equipment Operation and Maintenance Intelligent Agent Group" to solve it.

[0121] Step B: The description of the intelligent agent group contains a fixed process template for solving problems. When the large model breaks down the task, it can refer to this fixed process template to instantiate a process for solving complex problems based on the actual devices in the user's problem. Then, the user can remove the steps that are not needed for this task.

[0122] For example, the fixed process for the "Equipment Operation and Maintenance Intelligent Agent Group" to solve problems is as follows: 1. Call the time-lapse playback intelligent agent, use the time-lapse playback algorithm to trace back the data of the abnormal downtime period of [equipment xx], perform time-series characterization analysis on the data, and analyze the data situation; 2. Call the equipment anomaly detection intelligent agent to perform equipment anomaly detection on the data of [equipment xx] during [time period]; 3. Call the equipment fault diagnosis intelligent agent to perform equipment fault diagnosis on the data of [equipment xx] during [time period], and provide fault causes and maintenance suggestions; 4. Call the health assessment intelligent agent to perform health assessment on [equipment xx] and predict subsequent operating trends; 5. Call the professional report intelligent agent to provide a detailed analysis report.

[0123] By incorporating this process into prompts, the large model will provide the following instantiated process: 1. Call the time-lapse playback agent to use the time-lapse playback algorithm to trace back the data during the abnormal shutdown period of water pump No. 1, perform time-series characterization analysis on the data, and analyze the data situation; 2. Call the equipment anomaly detection agent to perform equipment anomaly detection based on the data of water pump No. 1 over the past three days; 3. Call the equipment fault diagnosis agent to perform equipment fault diagnosis based on the data of water pump No. 1 over the past three days, and provide fault causes and maintenance suggestions; 4. Call the health assessment agent to perform a health assessment on water pump No. 1 and predict subsequent operating trends; 5. Call the professional report agent to provide a detailed analysis report.

[0124] The large model removes step 5 based on the user's input question, and then the intelligent agent group begins to solve the problem.

[0125] Step C: The agent group assigns agent roles to solve problems according to the planned steps. Each agent role, during its construction, determines its own target scope and the order in which toolsets are used for each target scope. The agent role matches the step content to its own target scope, selects a target to participate in the construction of prompts, and uses a toolset usage order reference template to participate in the construction of prompts, allowing the large model to achieve the target in the reference order. Similarly, each toolset, during its construction, determines its own target scope and the order in which tools are used for each target scope. The toolset matches the step content to its own target scope, selects a target to participate in the construction of prompts, and uses a tools usage order reference template to participate in the construction of prompts, allowing the large model to achieve the target in the reference order.

[0126] The above process follows the React (reasoning-action) model. The tools return results with semantic information. The large model judges whether each tool returns the correct result and selects the next tool to approach the goal step by step. Finally, it judges whether the goal has been reached, exits the React process, and provides the answer. The entire process is displayed to the user, who can terminate or participate in the invocation of tools that require human confirmation in a timely manner.

[0127] For example, the goal of a health assessment agent is to obtain the health index of a device, obtain the device's health score, calculate the latest device health, and predict the device health trend. When the user issue mentioned above arrives, the health assessment agent considers it to match the latest device health target. The steps to achieve this goal are: 1. Call the health assessment toolset to provide the latest device health score; 2. Call the health score prediction toolset to provide a prediction of the device health for the next day.

[0128] For the health assessment toolset, the steps are as follows: 1. Call the health index value acquisition tool to obtain the health index value of the device; 2. Call the health assessment tool to give the latest health score of the device.

[0129] The steps for the health score prediction toolkit are as follows: 1. Call the historical device health score acquisition tool to obtain the historical device health score; 2. Call the health score prediction tool to provide a prediction of the device health score for the next day.

[0130] This knowledge is used to construct prompt words, and the large model will call on the tools in the toolset bound to the agent role to complete the goal.

[0131] For example: First, call the health index value acquisition tool (Tool 1), input the equipment code of water pump No. 1, and the health index value acquisition tool returns: the health index value of water pump No. 1 has been acquired, and the results are as follows: motor score: 95 points, pump body: 82 points; the large model judges the result to be valid, and considers the result to have been returned; call the health assessment tool (Tool 2), input the health index data of water pump No. 1, and the health assessment tool returns: the health score of water pump No. 1 has been acquired, and the results are as follows: the current score is 88 points; the large model judges the result to be valid, and considers the result to have been returned; ...; call the health score prediction tool (Tool 4), input the current score and historical data of water pump No. 1, and the health score prediction tool returns: the health score of water pump No. 1 has been predicted, and the results are as follows: it may drop to 80 points in the next day; the large model judges the result to be valid, and considers the result to have been returned; the goal is achieved, and the role results (health score and equipment health prediction for the next day) are output.

[0132] Similarly, the fault diagnosis agent outputs the cause of the fault and maintenance suggestions.

[0133] Finally, the results of each role are summarized and the entire process is presented to the user; user actions; task termination; if confirmed or due to error, a final analysis report is output.

[0134] This embodiment provides an intelligent question answering method. After the user inputs a complex domain question, the large model first matches the corresponding intelligent agent group. The intelligent agent group retrieves and instantiates a fixed process template. After removing redundant steps, the task is assigned to the corresponding intelligent agent role. The intelligent agent role calls the tools in the bound toolset in React mode according to the preset goal and tool usage order. The tools return results with semantic information. The large model judges the validity of the results and gradually advances the task. Finally, the results are summarized to generate a report, and the entire process is displayed to the user.

[0135] Example 4

[0136] This embodiment provides an intelligent question-answering system, which includes:

[0137] The domain-level intelligent agent system construction system described in Example 2, and

[0138] The intent recognition module is configured to: acquire the input question, perform intent recognition on the large model, and match the intelligent agent group.

[0139] The results generation module is configured to: retrieve the information of the matched agent group, combine it with the input question, allocate agent groups through a large model, and generate an instantiation process; based on the instantiation process, allocate agent roles, toolsets, and tools in sequence, and generate results.

[0140] It should be noted that each module in this embodiment corresponds one-to-one with each step in embodiment three, and their specific implementation process is the same, so it will not be repeated here.

[0141] The above description is merely a preferred embodiment of the present invention and is not intended to limit the invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for constructing a domain-level intelligent agent system, characterized in that, include: Obtain semantic descriptions and tags for the tools and store them in a graph database; In response to the toolset creation command, tools with the same label are associated to obtain a toolset; in response to the learning command, the large model calls the semantic descriptions of tools with the same label to generate toolset information; the toolset and tools are bound and stored in the graph database; the relevance of each semantic description is calculated, and when the average relevance of a semantic description with the other semantic descriptions is lower than the threshold, the technical staff is reminded to make corrections; In response to the agent role creation command, several toolsets are bound to the created agent role; in response to the learning command, the large model calls the bound toolset information to generate agent role information; Bind agent roles and toolsets to a graph database; In response to the agent group creation command, bind several agent roles to the created agent group; In response to learning instructions, the large model calls upon the bound agent role information to generate agent group information; and binds agent roles and agent groups to the graph database. The relevance is: ； in, Let i be the TF-IDF vector of the i-th semantic description. Let j be the TF-IDF vector of the j-th semantic description, and let length bias factor be the length bias factor. ; For smoothing term; adjustment factor ; λ 0 is the basic adjustment factor; entropy value M is the number of semantic descriptions, and the probability value is... Maximum entropy , N i This represents the total number of words in the i-th semantic description. N j This represents the total number of words in the j-th semantic description; The toolset information, agent role information, and agent group information all include functions, objectives, and invocation steps; The semantic description includes the tool's functions, input parameters, output result format, output semantics, and applicable scenarios; The learning is triggered either when the object is created or when the associated object is updated.

2. A domain-level intelligent agent system construction system, characterized in that, include: The data acquisition module is configured to acquire semantic descriptions and labels of the tools and store them in the graph database. The toolset creation module is configured to: respond to a toolset creation command, associate tools with the same label to obtain a toolset; respond to a learning command, the large model calls the semantic descriptions of tools with the same label to generate toolset information; bind the toolset and tools and store them in the graph database; calculate the relevance of each semantic description, and when the average relevance of a semantic description with the other semantic descriptions is lower than the threshold, remind the technical staff to make corrections. The role creation module is configured to bind several toolsets to the created agent role in response to an agent role creation command. In response to learning instructions, the large model calls upon the bound toolkit information to generate agent role information; Bind agent roles and toolsets to a graph database; The agent group creation module is configured to: in response to an agent group creation command, bind several agent roles to the created agent group; in response to a learning command, the large model calls the bound agent role information to generate agent group information; and bind the agent roles and agent groups to the graph database. The relevance is: ； in, Let i be the TF-IDF vector of the i-th semantic description. Let j be the TF-IDF vector of the j-th semantic description, and let length bias factor be the length bias factor. ; For smoothing term; adjustment factor ; λ 0 is the basic adjustment factor; entropy value M is the number of semantic descriptions, and the probability value is... Maximum entropy , N i This represents the total number of words in the i-th semantic description. N j This represents the total number of words in the j-th semantic description; The toolset information, agent role information, and agent group information all include functions, objectives, and invocation steps; The semantic description includes the tool's functions, input parameters, output result format, output semantics, and applicable scenarios; The learning is triggered either when the object is created or when the associated object is updated.

3. An intelligent question-answering method, characterized in that, A domain-level intelligent agent system constructed based on the domain-level intelligent agent system construction method as described in claim 1 includes: The input question is obtained, the large model performs intent recognition, and matches the intelligent agent group; Retrieve information from the matched agent groups, combine it with the input question, and use a large model to assign agent groups and generate instantiation processes. Based on the instantiation processes, assign agent roles, toolsets, and tools in sequence, and generate results.

4. The intelligent question-answering method as described in claim 3, characterized in that, The results are generated based on a reasoning-action model.

5. An intelligent question-answering system, characterized in that, include: A domain-level intelligent agent system construction system as described in claim 2, and The intent recognition module is configured to: acquire the input question, perform intent recognition on the large model, and match the intelligent agent group. The result generation module is configured to: retrieve the information of the matched agent group, combine it with the input question, allocate agent groups through a large model, and generate an instantiation process. Based on the instantiation process, agent roles, toolsets, and tools are assigned sequentially, and results are generated.

Images