A multi-agent collaborative dialogue as a service business agent construction method and system

Abstract

The application belongs to the technical field of artificial intelligence and natural language processing, and discloses a multi-agent collaborative dialogue as a service business agent construction method and system, which comprises the following steps: performing hierarchical intent recognition on a semantic request description, constructing a task dependency directed acyclic graph through recursive decomposition and dependency relationship recognition, and generating a task plan; combining short-term memory sliding window management and long-term memory semantic vector retrieval to generate an enhanced context representation; adaptively selecting and executing a corresponding reasoning mode for each task; encapsulating tools by using a preset model context standard protocol, and constructing a tool capability dynamic registration and scheduling management mechanism through a skill registration center; according to the tool capability dynamic registration and scheduling management mechanism, aggregating and arranging the task execution results and uniformly formatting them, and returning the formatted results to the user. The application realizes automatic decomposition and dynamic arrangement of a single natural language instruction to a multi-step task.

Description

Technical Field

[0001] This invention relates to the fields of artificial intelligence and natural language processing, and in particular to a method and system for constructing multi-agent collaborative dialogue-as-a-service business agents. Background Technology

[0002] With the rapid evolution of Large Language Model (LLM) technology, agent-based application systems are evolving from simple question-and-answer assistants to complex task execution systems. In converged media organizations such as broadcasting and television, staff face an urgent need to deeply integrate the traditional "planning, acquisition, editing, review, publication, and evaluation" process with AI technology. Single conversational AI tools can no longer meet the complex business processing requirements across systems, modalities, and processes.

[0003] Currently, multi-agent systems on the market mainly suffer from the following shortcomings: (1) In existing multi-agent dialogue strategy schemes, the collaborative relationships between agents are usually statically predefined, and multi-turn dialogue semantic understanding and strategy selection are achieved through fixed architectures such as semantic slot agents and decision networks. This type of scheme takes dialogue strategy optimization as its core objective, but it does not have the ability to dynamically assemble the execution link according to user intent, nor does it have a standardized mechanism to incorporate external tools and business systems into the agent execution closed loop. More importantly, this type of scheme does not solve the problem of deep integration of domain-specific knowledge and process-oriented arrangement of professional skills in professional fields (such as broadcast television content production).

[0004] (2) Existing multi-agent collaboration solutions partially adopt a multi-role agent collaboration model to generate responses, but focus on optimizing the quality of dialogue content generation without addressing issues such as tool invocation, business process orchestration, and cross-system task execution. In broadcast television scenarios, a typical content production task (such as the production of trending short videos) requires the integration of multiple professional processes, including trend monitoring, text generation, video synthesis, speech synthesis, and media asset retrieval. Existing solutions lack systematic methods for automating and standardizing these professional processes.

[0005] (3) Some existing solutions have introduced a master-slave agent hierarchical architecture and a task complexity classification mechanism, which has made progress in multi-agent scheduling architecture. However, their tool calls still rely on predefined function call interfaces and do not have the ability to dynamically discover and plug and play tools based on standardized protocols (such as the MCP protocol). Furthermore, they lack an adaptive decision-making mechanism that integrates chain-of-thought reasoning with the action-observation loop (ReAct) during the reasoning process. More importantly, these solutions lack the ability to think deeply about the multi-step process of complex tasks, that is, they cannot dynamically adjust the reasoning chain based on the actual tool return results during execution.

[0006] (4) At the business application level, existing large-scale model applications generally adopt single-turn or multi-turn dialogue modes, and the output content is mostly general text, lacking deep integration with specific domain knowledge bases, and unable to produce domain-specific content that conforms to professional standards. In the field of broadcasting and television, program planning, news copywriting, and broadcasting scripts all have strict industry standards and style requirements, and existing general-purpose AI systems cannot generate directly usable professional content without the support of domain knowledge bases.

[0007] Therefore, how to provide a method and system for constructing business intelligent agents for multi-agent collaborative dialogue as a service is an urgent problem to be solved. Summary of the Invention

[0008] This invention provides a method and system for constructing multi-agent collaborative dialogue-as-a-service business agents to solve the aforementioned technical problems in the prior art.

[0009] According to a first aspect of the present invention, a method for constructing multi-agent collaborative dialogue-as-a-service business agents is provided.

[0010] In one embodiment, a method for constructing a multi-agent collaborative dialogue-as-a-service business intelligence agent includes: receiving a dialogue request submitted by a user and encoding the dialogue request into a standardized semantic request description, the dialogue request including text, voice, and files; performing hierarchical intent recognition on the semantic request description, constructing a task dependency directed acyclic graph (DAG) through recursive decomposition and dependency relationship recognition, and generating a task plan based on the topological sorting result of the task dependency DAG; generating an enhanced context representation based on the current semantic request description, combining short-term memory sliding window management and long-term memory semantic vector retrieval; adaptively selecting and executing corresponding reasoning modes for each task by combining the task plan and the enhanced context representation, the reasoning modes including thought chain reasoning mode, action observation loop, and fusion mode; encapsulating tools using a preset model context standard protocol, and constructing a dynamic registration and scheduling management mechanism for tool capabilities through a skill registry center; and aggregating, organizing, and uniformly formatting the task execution results according to the dynamic registration and scheduling management mechanism for tool capabilities, and returning the formatted results to the user to realize the construction of the business intelligence agent.

[0011] According to a second aspect of the present invention, a multi-agent collaborative dialogue-as-a-service business agent construction system is provided.

[0012] In one embodiment, a multi-agent collaborative dialogue-as-a-service business agent construction system includes: a request receiving and encoding module, used to receive dialogue requests submitted by users and encode the dialogue requests into standardized semantic request descriptions, including text, voice, and files; a task decomposition and planning module, used to perform hierarchical intent recognition on the semantic request descriptions, construct a task dependency directed acyclic graph (DAG) through recursive decomposition and dependency recognition, and generate task planning based on the topological sorting result of the task dependency DAG; and a context enhancement module, used to combine the sliding window management of short-term memory and the semantic context of long-term memory based on the current semantic request description. The system comprises four modules: a data retrieval module to generate enhanced context representations; a reasoning mode selection module to adaptively select and execute corresponding reasoning modes for each task by combining task planning and enhanced context representations, including thought chain reasoning mode, action-observation loop, and fusion mode; a tool dynamic management module to encapsulate tools using a preset model context standard protocol and build a dynamic registration and scheduling management mechanism for tool capabilities through a skill registry center; and a result aggregation and delivery module to aggregate, organize, and uniformly format task execution results according to the tool capability dynamic registration and scheduling management mechanism, and return the formatted results to the user to realize the construction of the business intelligence agent.

[0013] According to a third aspect of the present invention, a computer device is provided.

[0014] In some embodiments, the computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the steps of the method described above.

[0015] According to a fourth aspect of the present invention, a computer-readable storage medium is provided.

[0016] In one embodiment, a computer program is stored on the computer-readable storage medium, which, when executed by a processor, implements the steps of the above method.

[0017] The technical solutions provided by the embodiments of the present invention may include the following beneficial effects: (1) This invention realizes automatic decomposition and dynamic arrangement of single natural language instructions to multi-step tasks through hierarchical intent recognition and task-dependent directed acyclic graph construction mechanism, which is different from the static predefined agent collaboration relationship in the prior art.

[0018] (2) By integrating the reasoning engine and its multi-step deep thinking mechanism, this invention solves the problem of insufficient efficiency of existing reasoning methods when facing mixed tasks. The reasoning process can dynamically adjust the decision path based on the real results returned by the tool.

[0019] (3) This invention achieves plug-and-play and dynamic discovery of external tools and business systems by standardizing the encapsulation of tools based on the model context standard protocol and the skill registry center, thereby reducing the marginal cost of system expansion.

[0020] (4) This invention realizes cross-session context inheritance and domain-specific knowledge reuse through a dual-layer memory architecture and memory fusion module, solving the problem of context information loss in long dialogue scenarios in existing systems.

[0021] (5) This invention ensures that the output content conforms to specific industry standards by using professional result processing based on domain knowledge base, and constructs an end-to-end closed loop from dialogue request to unified result delivery, realizing the AI-native dialogue as a service application paradigm.

[0022] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit the invention. Attached Figure Description

[0023] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with the invention and, together with the description, serve to explain the principles of the invention.

[0024] Figure 1 This is a flowchart illustrating an exemplary embodiment; Figure 2 This is a principle block diagram illustrated according to an exemplary embodiment; Figure 3 This is a schematic diagram of the structure of a computer device according to an exemplary embodiment; Figure 4 This is a schematic diagram of the overall architecture of a business intelligence agent construction method according to an exemplary embodiment. Detailed Implementation

[0025] The following description and accompanying drawings fully illustrate specific embodiments described herein to enable those skilled in the art to practice them. Some portions and features of certain embodiments may be included in or replace portions and features of other embodiments. The scope of the embodiments herein includes the entire scope of the claims and all available equivalents thereof. The various embodiments described herein are presented 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.

[0026] The modules in the apparatus or system of this application can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device in hardware form, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0027] Where there is no conflict, the embodiments and features in the embodiments of the present invention can be combined with each other.

[0028] Figure 1 An embodiment of a multi-agent collaborative dialogue-as-a-service business agent construction method of the present invention is shown.

[0029] In this optional embodiment, the method for constructing a multi-agent collaborative dialogue-as-a-service business agent includes: Step S101: Receive a dialogue request submitted by the user and encode the dialogue request into a standardized semantic request description. The dialogue request includes text, voice, and files. Step S102: Perform hierarchical intent recognition on the semantic request description, construct a task dependency directed acyclic graph through recursive decomposition and dependency relationship recognition, and generate task planning based on the topological sorting result of the task dependency directed acyclic graph. Step S103: Based on the current semantic request description, and combining the sliding window management of short-term memory with the semantic vector retrieval of long-term memory, an enhanced context representation is generated; Step S104: Combining task planning and enhanced contextual representation, adaptively select and execute the corresponding reasoning mode for each task. The reasoning modes include thought chain reasoning mode, action observation loop and fusion mode. Step S105: The tool is encapsulated using a preset model context standard protocol, and a dynamic registration and scheduling management mechanism for tool capabilities is built through the skill registry center. Step S106: Based on the tool capability dynamic registration and scheduling management mechanism, the task execution results are aggregated, organized, and uniformly formatted, and the formatted results are returned to the user to realize the construction of the business intelligence agent.

[0030] In this optional embodiment, hierarchical intent recognition is performed on the semantic request description. A task dependency directed acyclic graph (DAG) is constructed through recursive decomposition and dependency identification. Based on the topological sorting result of the task dependency DAG, a task plan is generated, including: using a pre-trained domain classification model to map the semantic request description to a predefined business domain category, and outputting the corresponding domain label and confidence score; constructing an explicit intent structure based on the domain label and confidence score, and performing semantic analysis on the semantic request description using chain-like reasoning to generate an implicit intent list to obtain the fusion request; analyzing the fusion request, generating a task sequence based on the analysis results through a recursive decomposition strategy, and constructing a task dependency DAG according to preset dependency identification rules; and generating a task plan using a greedy scheduling algorithm based on the topological sorting result of the task dependency DAG and the capability description information of the agent and tools.

[0031] In this optional embodiment, an explicit intent structure is constructed based on domain labels and confidence scores, and a chain-like reasoning method is used to perform semantic analysis on the semantic request description to generate an implicit intent list. This process for obtaining the fusion request includes: extracting target slots from the semantic request description using a preset sequence labeling model based on domain labels and confidence scores to construct the explicit intent structure; constructing a prompt template containing a reasoning chain using the chain-like reasoning method, and using the prompt template to guide a preset large language model to perform semantic analysis on the semantic request description to generate an implicit intent list; combining the explicit intent structure and the implicit intent list to update the semantic request description, and generating a fusion request based on the update results.

[0032] In this optional embodiment, the fusion request is analyzed, and a task sequence is generated based on the analysis results through a recursive decomposition strategy. A task dependency directed acyclic graph is constructed according to preset dependency identification rules. This includes: analyzing the number of action types, the number of operation objects, and the number of implicit intent list entries in the fusion request; determining whether the fusion request is a composite request based on the analysis results; if it is determined to be a composite request, recursive decomposition is performed to generate a task set, and the dependency and constraint relationships between tasks are identified according to preset dependency identification rules to construct a task dependency directed acyclic graph; if it is determined to be a non-composite request, the fusion request is treated as a single task, and a task dependency directed acyclic graph containing only a single task node is constructed.

[0033] In this optional embodiment, performing recursive decomposition to generate a task set includes: performing an initial decomposition of the fusion request according to the action type to generate multiple sub-requests, and performing a secondary decomposition of the operation objects in the sub-requests; using a preset large language model to evaluate the execution complexity of the sub-requests after the secondary decomposition; if the execution complexity exceeds a preset threshold, performing a third decomposition, repeating the complexity evaluation and decomposition operations until a preset recursion termination condition is reached to generate a task set; if the execution complexity does not exceed the preset threshold, the task set is directly generated.

[0034] In this optional embodiment, generating an enhanced context representation based on the current semantic request description, combined with sliding window management of short-term memory and semantic vector retrieval of long-term memory, includes: generating an updated short-term memory using sliding window and dynamic summarization techniques based on the current semantic request description and historical semantic request description; performing semantic vector retrieval from a pre-built vector knowledge base to obtain long-term memory retrieval results by combining the current semantic request description and the updated short-term memory; and performing attention-weighted fusion on the current semantic request description, the updated short-term memory, and the long-term memory retrieval results to generate an enhanced context representation.

[0035] In this optional embodiment, generating an updated short-term memory based on the current semantic request description and historical semantic request description, using sliding window and dynamic summarization techniques, includes: setting the maximum context window length to a preset target number of tokens, and using the current semantic request description and historical semantic request description as a dialogue round queue to initialize the short-term memory; during the dialogue interaction, after each dialogue round is completed, a new dialogue round is appended to the tail of the dialogue round queue, and the number of tokens for all rounds in the dialogue round queue is calculated; it is determined whether the number of tokens exceeds the preset target number of tokens. If so, the earliest round to be compressed is taken from the head of the dialogue round queue, the round to be compressed is concatenated into text, input into a preset summarization generation model, and the summary text is output and encapsulated as a summary entry to be inserted into the head of the dialogue round queue to generate an updated short-term memory; if not, an updated short-term memory is generated based on the current dialogue round queue.

[0036] In this optional embodiment, by combining task planning and enhanced context representation, a corresponding reasoning mode is adaptively selected and executed for each task. The reasoning modes include the thought chain reasoning mode, the action observation loop, and the fusion mode. The process includes: evaluating each task based on the task planning and enhanced context representation; selecting a corresponding reasoning mode based on the evaluation results; executing task scheduling and reasoning operations according to the selected reasoning mode; and performing format verification, logic verification, and integrity verification on the execution results of each step in sequence. If the verification passes, the subsequent reasoning process continues; if the verification fails, a dynamic replanning mechanism is triggered to adjust the reasoning mode.

[0037] In this optional embodiment, each task is evaluated based on task planning and enhanced context representation. A corresponding reasoning mode is selected based on the evaluation results. The reasoning modes include a thought chain reasoning mode, an action observation loop, and a fusion mode. The fusion mode involves: evaluating the complexity characteristics of each task and analyzing these characteristics, including reasoning depth, tool dependence, and information timeliness; if a task only contains logical reasoning and not tool invocation, the thought chain reasoning mode is selected; if a task aims for tool invocation and uses logical reasoning as an aid, the action observation loop mode is selected; if a task contains both logical reasoning and tool invocation, a fusion mode combining the thought chain reasoning mode and the action observation loop mode is selected. In this fusion mode, the observation results of the action nodes are fed back to subsequent reasoning nodes in real time.

[0038] Figure 2 An embodiment of a multi-agent collaborative dialogue-as-a-service business agent construction system of the present invention is shown.

[0039] In this optional embodiment, the multi-agent collaborative dialogue-as-a-service business intelligent agent construction system includes: The request receiving and encoding module 201 is used to receive dialogue requests submitted by users and encode the dialogue requests into standardized semantic request descriptions. Dialogue requests include text, voice, and files. The task decomposition and planning module 202 is used to perform hierarchical intent recognition on semantic request descriptions, construct a task dependency directed acyclic graph through recursive decomposition and dependency relationship recognition, and generate task planning based on the topological sorting results of the task dependency directed acyclic graph. The context enhancement module 203 is used to generate an enhanced context representation based on the current semantic request description, combining the sliding window management of short-term memory and the semantic vector retrieval of long-term memory; The reasoning mode selection module 204 is used to combine task planning and enhanced context representation to adaptively select and execute the corresponding reasoning mode for each task. The reasoning modes include the thought chain reasoning mode, the action observation loop and the fusion mode. The tool dynamic management module 205 is used to encapsulate tools using a preset model context standard protocol and to build a dynamic registration and scheduling management mechanism for tool capabilities through the skill registry center. The result aggregation and delivery module 206 is used to aggregate, organize, and uniformly format task execution results according to the tool's dynamic registration and scheduling management mechanism, and return the formatted results to the user to realize the construction of business intelligence agents.

[0040] like Figure 4As shown, to facilitate understanding of the above technical solutions of the present invention, the following further explains the above technical solutions of the present invention from the perspective of architecture and principle, as follows: Step 1: Dialogue Request Reception and Unified Encoding of Multimodal Signals: Receive dialogue requests submitted by users through the interaction layer. These requests include one or more combinations of text input, voice input, and file upload. Perform Automatic Speech Recognition (ASR) processing on the voice input to obtain text transcription results. Perform document parsing, image recognition, or audio / video feature extraction processing on the uploaded file to obtain a structured content description. Unify all inputs into a standardized Semantic Request Descriptor (SRD). The SRD contains original text information, a structured representation of multimodal attachments, and user identity and session context identifiers.

[0041] Step 2: Based on hierarchical intent recognition, task decomposition and execution planning are performed on the generated SRD to conduct hierarchical intent recognition processing, specifically including: 1. Domain Intent Classification: Through a pre-trained domain classification model, user requests are mapped to predefined business domain categories (such as content production, media asset retrieval, data analysis, office collaboration, etc.), and domain labels and confidence scores are output.

[0042] 2. Fine-grained Intent Analysis: Chain-of-Thought (CoT) is used to perform deep semantic analysis of user requests, identifying explicit and implicit intents, and extracting structured information such as task objectives, constraints, and expected output formats. The specific implementation steps for using CoT to perform deep semantic analysis of user requests and identify explicit and implicit intents are as follows: (1) Request preprocessing and normalization: Preprocessing is performed on the natural language request input by the user, including: word segmentation and part-of-speech tagging (using a dual engine of jieba word segmentation and THULAC part-of-speech tagging, taking the result with higher confidence), coreference resolution (replacing pronouns with entities in the preceding context, based on a combination of rule-based and BERT-based coreference resolution model), and omission recovery (completing omitted subjects or objects based on the dialogue context). The normalized text after preprocessing is used as input for subsequent inference. (2) Explicit Intent Extraction: Normalized text is input into a pre-trained domain classification model (based on BERT-base-Chinese fine-tuning, 12 business domains), and the output domain labels and confidence scores are output. At the same time, a sequence labeling model (BiLSTM-CRF architecture) is used to extract key slots in the text, including action type (such as query, generate, analyze, edit), operation object (such as program, material, data report), constraints (such as time range, format requirements, quality standards), and expected output format (such as table, chart, text, video). The extraction results constitute the explicit intent structure ExplicitIntent={domain, action, object, constraints, output_format}. (3) Implicit Intent Reasoning: Based on the CoT (Chain Thinking) method, a prompt template containing a reasoning chain is constructed to guide the large language model to perform a step-by-step in-depth analysis of user requests. Specifically, the system prompt words contain the following reasoning instruction sequence: analyze the user's business role and current work scenario, and infer from the conversation context and user profile; identify implicit needs that are not explicitly expressed in the request text but should be included based on business logic, such as when a user asks for help to plan a health program, the implicit needs include: needing to match the health program style template, needing to search for recent health-related hot topics, needing to generate content that matches the audience profile of the program, etc.; reason about the user's possible subsequent needs, such as needing to add voice-over and pictures after generating the plan; based on the above reasoning results, output the implicit intent list ImplicitIntents=[{intent_type, confidence, reasoning_chain}]; each implicit intent is accompanied by a complete reasoning chain (reasoning_chain) for interpretability display. (4) Intent fusion and SRD enhancement: Explicit intent and implicit intent are fused, the generated SRD (Structured Request Description) is updated, the implicit_intents field and the enriched_constraints field are added, and the constraints discovered by implicit reasoning are added to the constraint list.

[0043] 3. Task decomposition and dependency graph construction: When a user request contains multiple sub-tasks, the composite request is decomposed into a sequence of atomic tasks using a recursive decomposition strategy, and a task dependency DAG is constructed; (2d) Execution plan generation: Based on the topological sorting result of the DAG, combined with the capability description information of available agents and tools, an execution plan is generated using a greedy scheduling algorithm; The specific steps of the recursive decomposition strategy to decompose the composite request into a sequence of atomic tasks and construct the task dependency DAG, and the generation of the execution plan using the greedy scheduling algorithm are as follows: (1) Composite judgment: For the merged SRD, determine whether it is a composite request: If the SRD contains multiple actions or multiple objects, or the implicit intent list contains more than 2 entries, it is determined to be a composite request and enters recursive decomposition; otherwise, it is directly processed as a single atomic task. (2) Recursive decomposition: Perform top-down recursive decomposition on the composite request; specifically, the first level of decomposition: according to the action type, the SRD is split into multiple sub-requests, each sub-request corresponds to an independent action, such as query and generation are split into query sub-tasks and generation sub-tasks; the second level of decomposition: for each sub-request, if its object is a composite object, such as multiple programs, it is further split according to object; the third level of decomposition: for each sub-request, if its execution_complexity (evaluated by the large language model) exceeds the set threshold (complexity_threshold=3, range 1-5), it is further decomposed into finer-grained atomic operations; the recursion termination condition: the complexity evaluation value of the sub-task is less than or equal to complexity_threshold, or the maximum recursion depth (max_recursion=4) has been reached. (3) Dependency identification and DAG construction: For the atomic task set T={t1, ..., t_n} obtained by decomposition, the dependencies between tasks are identified according to the following rules: Data dependency, if t j The input data includes t i The output data is determined by analyzing the field matching relationship between the input_schema and output_schema of each task. i >t jSemantic dependency: Use a large language model to determine whether there is a logical order between two tasks, such as retrieval before generation; Resource dependency: If two tasks compete for the same exclusive resource, such as the concurrency limit of the same MCP Server, then establish mutual exclusion constraints; Construct all dependencies into a directed acyclic graph DAG_task, verify acyclicity by topological sorting, and remove the edge with the lowest confidence in the semantic dependency if a cycle is detected. (4) Initialization of ready task set: Perform topological sorting on DAG_task and add tasks with an in-degree of 0 (no predecessor dependency) to the ready queue ReadyQueue. (5) Task-agent matching score: For each task t in ReadyQueue i Iterate through the list of capability descriptions for available agents and tools, CapList, and calculate the matching score: MatchScore(t i cap j =w1*SemanticSim(t i .description,cap j .description)+w2*TypeMatch(t i .action,cap j .supported_actions)+w3*LoadFactor(cap j ), where SemanticSim is the semantic similarity based on Sentence-BERT, TypeMatch is the exact match of action type, matching is 1, not matching is 0, LoadFactor is the reciprocal of the agent's current load (idle agents have higher scores), weight w1=0.4, w2=0.4, w3=0.2. (6) Greedy allocation: According to the DAG_task topology order, select the agent or tool with the highest MatchScore for each ready task for allocation; for tasks that can be executed in parallel, multiple ready tasks without dependencies in the DAG are simultaneously allocated to different agents for parallel execution; for tasks with mutually exclusive resource constraints, they are queued according to priority, where priority = the position of the task on the critical path of the DAG, and the tasks on the critical path have higher priority. (7) Execution plan output: Serialize the allocation result into an execution plan ExecPlan=[{step_id,task,assigned_agent,depends_on,parallel_group}], where parallel_group identifies the task group that can be executed in parallel.

[0044] Step 3: Context Management and Knowledge Fusion Based on a Two-Layer Memory Architecture: During task execution, a dual-layer memory architecture is used to maintain and manage contextual information, providing contextual support for intent recognition and reasoning decisions. This dual-layer memory architecture includes: short-term working memory, employing a management strategy combining sliding windows and dynamic summarization. Within a preset context window length, it fully retains the original content of recent multi-turn dialogues; historical dialogues exceeding the window length undergo automatic summarization and compression, achieving lossless preservation of key information under limited context length constraints. Long-term knowledge memory uses a vector knowledge base for persistent storage, storing user preferences, business knowledge, and domain-specific knowledge (such as broadcasting industry standards, program style templates, and professional terminology) generated during historical interactions into a vector database. Relevant knowledge is injected through semantic vector retrieval during each new dialogue processing, enabling cross-session professional knowledge reuse. Finally, a memory collaboration mechanism is implemented, where short-term working memory and long-term knowledge memory collaborate through a memory fusion module. This module performs attention-weighted fusion of the current round's context, long-term memory retrieval results, and the current SRD (Signal Rendering Result) to generate an enhanced contextual representation.

[0045] 1. The management strategy combining sliding windows and dynamic summarization, and the specific steps of automatic summarization and compression processing are as follows: (1) Sliding window maintenance: Set the context window length to W max One token (default W) max =8192), the system maintains an ordered dialog round queue DialogQueue. Each dialog round is stored as a triple (user_input, assistant_response, timestamp). New dialog rounds are appended to the tail of the queue. When the total number of tokens for all rounds in the queue exceeds W... max Automatic digest compression is triggered when compression is triggered. (2) Automatic digest compression processing: When compression is triggered, the following steps are performed: The earliest K rounds of dialogue are retrieved from the head of DialogQueue, where K is the number of tokens in the remaining rounds that will fall back to W. max *Minimum value below 0.7; Concatenate these K rounds of dialogue into text and input it into the summary generation model, which is based on the DeepSeek large language model and uses a special summary prompt template: Please compress the following dialogue into a summary of key information, retaining: the user's explicitly expressed needs and preferences, important decisions and conclusions, key data and values, and unfinished tasks; The summary text output by the model is encapsulated as a special SummaryEntry, inserted into the DialogQueue header, and replaces the compressed K rounds of original dialogue; The SummaryEntry is marked with the compression ratio and the original round range, allowing users to actively expand and view the summary details (by retrieving the original dialogue from long-term memory).

[0046] 2. Specific construction methods for vector knowledge bases: (1) Data sources and collection: The data sources of the vector knowledge base include: user historical interaction data, extracting user preferences, common operation modes, and areas of interest from dialogue logs; business knowledge documents, including broadcast and television industry standard documents, style templates for various columns (such as the popular science narrative standard of Health Hall, the legal commentary standard of Legal Times, etc.), and station management system; domain-specific knowledge, professional terminology database, industry standards, policies and regulations, etc. (2) Text segmentation strategy: A hierarchical segmentation strategy is adopted for the original documents: the first level is semantic segmentation according to document chapters or paragraphs, with a target length of 512 tokens per block, allowing a 20% fluctuation; the second level is to use a sliding window to segment super long paragraphs according to sentence boundaries, with a window size of 512 tokens and a step size of 384 tokens, i.e., 128 tokens overlap to maintain semantic coherence; each text block is accompanied by metadata: {source_doc, chunk_index, doc_type, create_time, update_time}. (3) Vectorization: The BGE-large-zh text embedding model (1024-dimensional output) is used to encode each text block into a dense vector; the query-passage asymmetric encoding strategy is adopted during encoding: the knowledge text block uses the passage encoder and adds the passage: prefix, and the retrieval query uses the query encoder and adds the query: prefix to improve retrieval accuracy. (4) Index structure design: The HNSW (Hierarchical Navigable Small World) graph index is adopted, with the following parameter settings: M=32 (maximum number of connections per node), ef_construction=256 (search range during construction), ef_search=128 (search range during query); the index is stored in partitions according to the knowledge base type: public knowledge base, column knowledge base, and personal knowledge base are each indexed independently, and selective search is performed according to the permission range during retrieval. (5) Update mechanism: An incremental update strategy is adopted, and newly added knowledge documents are encoded and inserted into the index in real time; modified documents are re-encoded and inserted after deleting the old vectors; expired documents are marked as inactive, do not participate in retrieval but are retained for historical traceability; a full index reconstruction is performed regularly (weekly) to optimize retrieval efficiency.

[0047] 3. Specific implementation steps for attention-weighted fusion to generate enhanced contextual representations: (1) Multi-source information preparation: Three inputs are collected, including: the current round context C_current, which contains the dialogue history (including summary) within the sliding window and the current user input, encoded into a d-dimensional vector sequence by the BERT encoder; the long-term memory retrieval result C_memory, which uses the current user request as the query to perform Top-K nearest neighbor retrieval (K=5) in the vector knowledge base, and the returned K knowledge blocks are encoded into a d-dimensional vector sequence by the BERT encoder; and the current SRD C_memory. srd The generated structured request description is serialized into text and then encoded into a d-dimensional vector. (2) Cross-attention calculation: Using C srd As Query(Q=W) Q *C srd ), with C current and C memory The concatenated sequence serves as the key and value (K=W) K *[C current ;C memory ], V=W V *[C current ;C memory ]), perform multi-head cross-attention calculation: Attention(Q, K, V) = softmax(QK) T / sqrt(d k ))*V, using 8-head attention, d k =d / 8; This calculation enables each semantic component in the SRD to adaptively focus on relevant fragments in the current dialogue context and relevant knowledge in long-term memory. (3) Enhanced context generation: The attention output is passed through LayerNorm and a feedforward network (FFN: Linear(d,4d)->GELU->Linear(4d,d)) and then compared with the original C. srd By adding the residual connections, we obtain the enhanced context representation C. enhanced This enhancement means that the current dialogue context, historical knowledge, and structured request information are integrated as inputs to the reasoning decision engine.

[0048] Step 4: Multi-step deep thinking and adaptive decision-making based on CoT-ReAct fusion reasoning: Based on the generated execution plan and enhanced context representation, adaptive decision-making and task scheduling are performed through the CoT-ReAct fusion inference engine. The operation of the fusion inference engine includes: adaptive selection of inference mode: evaluating the complexity characteristics (inference depth, tool dependency, information timeliness) of each atomic task and automatically selecting pure CoT mode, pure ReAct mode, or CoT-ReAct fusion mode; multi-step deep thinking in fusion mode: first, generating a hybrid execution chain containing inference nodes and action nodes through CoT inference, and then executing them sequentially according to the node order. When encountering an inference node, CoT deep analysis is performed, and when encountering an action node, ReAct loop execution of tool calls is entered. The observation results of each action are fed back to the subsequent inference chain in real time, so that the inference process is dynamically adjusted based on real observations rather than preset assumptions; tool call execution: in the action phase of the ReAct loop, external tools and business systems are called through the MCP standard protocol; error detection and replanning: three-level verification (format, logic, completeness) is performed on the execution results of each step, and a replanning mechanism is triggered when failure occurs; multi-agent collaborative execution: the master agent is responsible for task distribution and result aggregation, and each professional agent executes independently and returns results.

[0049] 1. Specific implementation steps for atomic task complexity assessment and inference mode selection: (1) Complexity feature extraction: For each atomic task t i We extracted three quantitative metrics for complexity dimensions: Reasoning Depth (D_reason), which is evaluated by a large language model as the number of logical reasoning steps required for the task, ranging from 1 to 5. For example, a simple query is 1, while a deep analysis requiring multiple reasoning steps is 5. Tool Dependency (D_tool), which counts the number of external tools or APIs that the task needs to call. 0 indicates pure reasoning without tools, while 3+ indicates that multiple tools are required. Information Timeliness (D_realtime), which assesses the timeliness requirements of the information required for the task. 0 indicates no timeliness requirements and existing knowledge can be used, while 1 indicates that real-time data is required. (2) Reasoning mode decision: Based on the complexity feature vector (D_reason, D_tool, D_realtime), the reasoning mode is automatically selected according to the following rules: When D_tool=0 and D_reason<=2, the pure CoT mode is selected, which is suitable for simple analysis tasks that only require internal knowledge reasoning and do not require calling external tools; when D_reason<=1 and D_tool>=1, the pure ReAct mode is selected, which is suitable for simple tool calling tasks, such as direct retrieval and direct API calling; when D_reason>=2 and D_tool>=1, or D_realtime=1, the CoT-ReAct fusion mode is selected, which is suitable for complex tasks that require deep reasoning and combined with real-time tool calling.

[0050] 2. Specific implementation steps of CoT in-depth analysis: (1) Initialization of the inference chain: The system constructs an inference prompt template, injects the atomic task description, enhanced context C_enhanced and domain knowledge (relevant specifications retrieved from RAG) into the template, and guides the large language model to conduct analysis in a step-by-step inference manner; the prompt template contains the following structured instructions: Please perform step-by-step inference analysis on the following tasks. Each step of inference requires: clarifying the inference goal of this step; performing logical deduction based on existing information; marking the inference confidence (high, medium, low); if external information is needed, it is marked as [NEED_ACTION]. (2) Step-by-step inference execution: The large language model outputs the inference chain ReasonChain=[step_1, step_2, ...] step by step according to the prompt template. Each step contains {goal, reasoning, conclusion, confidence, need_action}; the system parses the output of each step: if need_action=false, it continues to the next step of inference; if need_action=true, it pauses CoT and switches to ReAct to execute the tool call in a loop. The call result is injected into the inference chain as an observation and then CoT inference continues. (3) Verification of reasoning results: After the reasoning chain is completed, the system performs a self-consistency check: three reasoning chains are generated for the same task with different temperature parameters (temperature=0.3, 0.5, 0.7), and the final conclusions are compared. If at least two of the three chains are consistent, the majority conclusion is adopted; otherwise, replanning is triggered.

[0051] 3. Specific implementation steps for calling external tools and business systems: (1) Tool selection: When the [NEED_ACTION] flag appears in the CoT inference chain, the system extracts the tool capability description required for this step, retrieves the Top-3 candidate tools in the Skills registry through semantic matching, and selects the tool with the highest matching score that is currently available (healthy status, not reaching the concurrency limit). (2) Parameter construction: According to the input parameter format (input_schema) defined in the tool's standardized capability description file, the corresponding parameter values ​​are extracted from the inference chain context to construct the tool call request; for cases where required parameters are missing, the system attempts to infer them from the enhanced context C_enhanced, and if it still cannot obtain them, it sends a confirmation request to the user. (3) MCP protocol call: The system sends a call request to the target MCP Server through the MCP standard protocol. The request format follows the MCP specification: {method, params, context_id}; the system sets a timeout threshold (default 30 seconds), and if no response is received within the timeout period, it is marked as a call failure. (4) Observation processing: Receive the results (Observation) returned by the tool, perform format standardization (unify the heterogeneous return formats of different tools into the {status, data, metadata} structure), and inject the standardized results into the current inference chain as the input basis for subsequent inference steps.

[0052] 4. Specific details of the replanning mechanism: The replanning mechanism is triggered in the following three situations: tool call failure, timeout, return error, or return data format abnormality; inference result verification failure, self-consistency check failure; failure of any level of the three-level verification (format verification / logic verification / integrity verification); after triggering, the following steps are executed: (1) error diagnosis, analyze the reasons for failure and classify them (tool unavailable / parameter error / inference path error / insufficient data); (2) strategy selection, for unavailable tools, execute tool replacement (select the candidate tool with the second highest matching score); for parameter errors, execute parameter correction (adjust parameters based on error information); for inference path errors, execute path backtracking (reverse to the last high confidence step in the inference chain and re-infer); for insufficient data, execute information supplementation (expand the RAG retrieval scope or request supplementary information from the user); (3) the maximum number of replanning times is 3 times. If the maximum number is exceeded, the current status and error information will be fed back to the user and manual intervention will be requested.

[0053] 5. Role definition, functional positioning, and interaction mechanism of the main intelligent agent and various specialized intelligent agents: The Master Agent, the core scheduling engine of the media AI assistant, is driven by the DeepSeek large language model. Its functions include receiving user requests, identifying and decomposing execution intentions, generating execution plans, distributing tasks to specialized agents, aggregating results, and delivering them uniformly. Technical implementation: The Master Agent runs the CoT-ReAct fusion inference engine, maintains the global session state and execution plan state machine, and communicates with various specialized agents through the MCP protocol.

[0054] Professional intelligent agents are categorized as follows: Content production agents, including hot topic acquisition agents (dedicated to monitoring and pushing hot topic data across the entire network in real time), topic analysis agents (performing event context analysis and key figure identification), in-depth interpretation agents (generating in-depth analysis text based on CoT inference), and content generation agents (coordinating multimodal AIGC engines to generate text / voice / video content); Knowledge service agents, including knowledge retrieval agents (performing RAG retrieval and knowledge base question answering), and data analysis agents (performing structured data querying and visualization); and tool service agents, including media asset retrieval agents (retrieving the audio-visual material library within the platform), and office collaboration agents (interfacing with OA systems, calendars, approval processes, etc.).

[0055] Interaction Mechanism: The main agent and specialized agents communicate asynchronously via message communication. The main agent sends atomic tasks to the matched specialized agents through TaskDispatch messages, which contain {task_id, task_description, input_data, expected_output_schema, timeout}. After independent execution, the specialized agents return results via TaskResult messages, containing {task_id, status, output_data, execution_log}. The main agent maintains a task status table, triggers retries or replanning for tasks that time out and fail to return results, and aggregates the execution results after all tasks are completed.

[0056] Step 5: Dynamic Management of Tool Capabilities Based on MCP Protocol and Skills Registration System: A dynamic management mechanism for tool capabilities based on the MCP protocol and Skills registration system is constructed, specifically including: MCPServer standardized encapsulation: Each external tool or business system is encapsulated as an independent MCP Server instance, and the function list, input and output parameter format, and calling constraints are declared through standardized capability description files; Skills capability registration and discovery: A Skills capability registration center is built, and dynamic tool discovery is achieved through semantic matching algorithms; Capability hot-plugging and version management: Supports dynamic registration / deregistration of MCP Servers at runtime, and maintains version information and health status. The three sub-steps form a progressive tool capability management pipeline: The MCP Server standardized encapsulation is the foundation layer, unifying heterogeneous external tools and business systems into a standardized interface and outputting standardized capability description files; Skills capability registration and discovery is the index layer, receiving the output capability description files and registering them to the Skills registry center, building a capability index that enables the inference engine to dynamically discover available tools through semantic matching; Capability hot-plugging and version management is the operations layer, providing runtime dynamic registration / deregistration capabilities based on the registry center, maintaining the version information and health status of each MCP Server, and ensuring that the latest available tool list is obtained when executing tool calls; the data flow of the three is: external tools, standardized encapsulation, capability description files, registration to the index, runtime state management, and querying available tools. Furthermore, in this invention, step five is located at the tool infrastructure layer, providing tool support for the execution of steps one to four: the natural language processing tools (word segmentation, NER, etc.) in step one, the domain classification model in step two, the vector knowledge base retrieval engine in step three, and the external tool calls in step four are all encapsulated in the form of an MCP Server and managed through step five; step five is an intermediate bridge connecting AI inference capabilities (steps one to four) and external business systems (delivered to users in step six), realizing the decoupling of the inference engine and tool resources, so that when adding or replacing business systems, only a new MCP Server needs to be registered without modifying the inference logic.

[0057] Step Six: Specialized Result Aggregation and Unified Delivery Based on Domain Knowledge Base: The system aggregates and uniformly formats the results of all atomic tasks for delivery. Specifically, this includes: result aggregation and domain-specific processing: integrating results according to the user's original output format expectations; professionally refining text-based results using domain knowledge base standards (such as broadcast script standards and program style templates) to ensure the output conforms to industry standards; source tracing and annotation: automatically annotating information sources, including data source system, retrieval time, and knowledge base origin, ensuring traceability; and interactive result presentation: returning results to the user through an interactive layer, supporting further inquiries, modifications, and iterations. The system maintains the continuity of the conversation context, achieving a continuous interactive experience of "dialogue as a service." The dynamic management mechanism for tool capabilities provides two aspects of support for result aggregation and unified delivery: data format standardization. Since all external tools are encapsulated as standardized MCP Servers, the result formats returned by each tool are unified, so there is no need to process heterogeneous data formats when performing result aggregation. Structured aggregation can be performed directly according to the unified output_schema. Source tracing capability. Each MCP Server's capability description file contains source identifiers (metadata such as source_system and api_version). When performing source tracing and reference annotation, these metadata are directly referenced to generate data source annotations.

[0058] The business intelligence agent system of this invention adopts a four-layer architecture design, which consists of the following layers from top to bottom: interaction layer, intelligence agent routing layer, capability and tool layer, and intelligence agent cluster layer. The specific implementation of each layer is explained below in conjunction with the actual implementation scenario of the media AI assistant of a broadcasting and television station.

[0059] I. Interaction Layer: The interaction layer is the interface layer for user interaction with the system, providing multimodal input reception and rich media result presentation capabilities. In this embodiment, the interaction layer includes two deployment forms: PC Web terminal and mobile terminal, supporting text input, voice input (integrated ASR engine, standard Mandarin recognition rate ≥95%), and file upload (supporting multiple formats such as images, documents, audio and video). Output supports streaming return of Markdown rich text, embedded images, audio and video players, data tables, and visualization charts. The core value of the interaction layer is to provide users with a unified native AI entry point, aggregating all AI capabilities into a single dialogue window, so that users do not need to understand the specific composition and calling methods of the underlying system.

[0060] II. Agent Routing Layer: The agent routing layer is the core decision-making layer of the system, comprising three core sub-modules: intent recognition and planning, memory, and inference engine. The intent recognition and planning module adopts a four-stage hierarchical processing flow: domain classification - CoT fine-grained parsing - DAG construction - execution plan generation. The CoT fine-grained parsing stage guides the large language model to perform multi-step intent analysis through deep thinking prompts, including core target identification, sub-task decomposition, constraint extraction, and dependency analysis. The memory module adopts a two-layer architecture: short-term working memory ensures the continuity of dialogue context through a sliding window (W=20 rounds) and dynamic summarization, while long-term knowledge memory stores information through a vector database. Domain-specific knowledge, such as broadcasting and television industry standards, program style templates, and professional terminology, is used to achieve collaborative work between two layers of memory through the attention weighting mechanism of the memory fusion module. The inference engine adopts the CoT-ReAct fusion inference method. Its core innovation lies in generating a hybrid execution chain containing inference nodes and action nodes in the fusion mode. The inference nodes perform CoT deep analysis, and the action nodes perform ReAct loop tool calls. The action observation results are fed back to the subsequent inference chain in real time, realizing dynamic decision-making based on real observations. The core value of the intelligent agent routing layer is to realize the full-link automation from understanding intent to planning execution to intelligent decision-making, which is the core technical barrier that distinguishes it from existing multi-agent systems.

[0061] III. Capability and Tool Layer: The capability and tool layer provides all the underlying capabilities required for the system to perform tasks. It is uniformly managed through the MCP protocol and the Skills registration system, including: large model management (unified interface to adapt to multiple vendors' LLMAPI), toolsets (MCP Server groups such as network retrieval, knowledge base retrieval, in-platform business plugins, and multimodal processing), and a Skills registration center (maintaining a global capability directory, supporting semantic matching discovery and capability hot-plugging). The core value of the capability and tool layer is to unify heterogeneous business systems into "plug-and-play" capability units through standardized protocols. New tools can be integrated without modifying the system code, greatly reducing the marginal cost of capability expansion.

[0062] IV. Intelligent Agent Cluster Layer: The intelligent agent cluster layer deploys various specialized intelligent agents, including text generation agents, image generation agents, video generation agents, data analysis agents (ChatBI), digital human agents, and hotspot analysis agents. Each agent is encapsulated through the MCP Server standard, supporting three collaborative modes: serial execution, parallel execution, and conditional branching. The core value of the intelligent agent cluster layer is to encapsulate the professional skills of the entire broadcast television content production process into dynamically scheduled execution units through domain-specific intelligent agent clusters, achieving deep embedding of AI into professional workflows.

[0063] Furthermore, the mapping relationship between the eleven core functions provided by the business intelligence system of the present invention and the four-layer architecture is shown in Table 1.

[0064] Table 1 - Mapping Relationship between Core Functions and Architecture

[0065] The following describes the complete execution process of the method of this invention using a typical broadcast television converged media business scenario; Scenario description: An editor at a TV station inputs through a media AI assistant: "Help me find the three hottest social news stories today," then writes a 200-word short video script based on the first news story and generates an accompanying image; The execution process is as follows: Step 1: The interaction layer receives text input and generates a Sub-Rate Script (SRD). The original text in the SRD is the user input content, without multimodal attachments, and the user's identity is the editor's employee ID. Step 2: The agent routing layer's intent recognition and planning module processes the SRD, classifying it as content production (confidence 0.92). CoT deep thinking parses three sub-tasks: Task 1 (hotspot retrieval), Task 2 (copywriting), and Task 3 (image generation). A DAG is constructed to form a linear dependency chain of Task 1-Task 2-Task 3. The execution plan assigns the corresponding agent and MCP tool. Step 3: The memory module loads the editor's context information. Short-term memory indicates this is a new session; long-term knowledge memory retrieval reveals the editor's previous preference for a concise and clear copywriting style, and also retrieves professional standards for broadcast television short video copywriting (word count control, colloquial expression, attractive opening, etc.), injecting user preferences and professional standards into the enhanced context. Step 4: The inference engine executes the execution plan sequentially. Execution Task 1: Select ReAct mode and retrieve the MCP via network connection. The server retrieves today's trending social news and extracts the top three. Task 2 is executed: The CoT-ReAct fusion mode is selected. The CoT phase deeply analyzes the core information points of the news, determines the narrative structure and language style (combining user preferences from long-term memory and professional standards from the knowledge base), and then ReAct calls a text generation agent to output a 200-word draft. CoT then performs another deep analysis to verify the word count and content accuracy. Task 3 is executed: ReAct mode calls an image generation agent to output accompanying images. Step 5 (interspersed within Step 4): All tool calls are executed via the MCP protocol, and the inference engine dynamically queries available tools through the Skills registry. Step 6: The results aggregation module integrates the outputs of the three tasks into a unified response, displayed in rich text format: first, summaries of the three trending news items are listed; then, short video text (combining professional standards from the domain knowledge base) is displayed; finally, the generated accompanying image is displayed, with source information annotated next to the text and image. Users can continue to ask follow-up questions based on this result, and the system continues processing while maintaining the complete context.

[0066] In summary, existing multi-agent systems employ fixed policy networks or a single reasoning paradigm for inference and decision-making. This invention proposes fusing CoT and ReAct and designs an adaptive mode selection mechanism based on task complexity characteristics. Particularly in the fused mode, a hybrid execution chain is generated to achieve alternating execution of inference and action nodes. Action observation results are fed back to the inference chain in real time, enabling the inference process to dynamically adjust based on real observations. This achieves an organic combination of multi-step deep thinking and tool invocation. The essential difference between this mechanism and existing hierarchical scheduling schemes is that the fused inference in this method occurs within the decision-making process of a single task, rather than being limited to task-to-task distribution and scheduling. Existing technologies rely on predefined function call interfaces for tool invocation, requiring system code modification for each new tool. This invention encapsulates each external tool using the MCP standard protocol and achieves unified registration, semantic discovery, and dynamic invocation of tools through a Skills registry center. During execution, the inference engine dynamically discovers the most matching tool through semantic matching, enabling plug-and-play tool capabilities and fundamentally solving the scalability problem of tool extensions. Existing systems generally employ fixed-length context windows, discarding historical information exceeding the window size, and lack deep integration with domain-specific knowledge. This invention designs a two-layer architecture of short-term working memory (sliding window and dynamic summary) and long-term knowledge memory (vector database and domain knowledge base), achieving collaborative work between the two through a memory fusion module. Dynamic summarization maintains the integrity of key semantics while compressing information, and attention-weighted fusion ensures that historical information and domain knowledge most relevant to the current request receive the highest weight, realizing cross-session context inheritance and professional knowledge reuse. Existing technologies use a flat recognition method of one-time intent classification, which is difficult to handle composite requests containing multiple subtasks and complex dependencies. This invention proposes a four-stage hierarchical processing flow: domain classification - CoT multi-step deep thinking analysis - DAG construction - execution plan generation. Through explicit modeling of task-dependent DAGs, the system can identify data dependencies and parallelism between tasks, generating optimized execution scheduling schemes. Especially in broadcast television content production scenarios, a content production task often involves multiple professional stages such as hotspot monitoring, copywriting, visual design, video synthesis, review and release. This method can automatically identify the dependencies between these stages and arrange the optimal execution path.

[0067] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 3As shown, the computer device includes a processor, memory, and a network interface connected via a system bus. The processor provides computing and control capabilities. The memory includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores an operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The database stores static and dynamic information data. The network interface communicates with external terminals via a network connection. When the computer program is executed by the processor, it implements the steps in the above method embodiments.

[0068] Those skilled in the art will understand that Figure 3 The structure shown is merely a block diagram of a portion of the structure related to the present invention and does not constitute a limitation on the computer device to which the present invention is applied. A specific computer device may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0069] In addition, the present invention also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above method embodiments.

[0070] In addition, the present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps in the above method embodiments.

[0071] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the methods described above. Any references to memory, storage, databases, or other media used in the embodiments provided by this invention can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, or optical storage, etc. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc.

[0072] This invention is not limited to the structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this invention is limited only by the appended claims.

Claims

1. A method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents, characterized in that, The method includes: Receive user-submitted dialogue requests and encode the dialogue requests into standardized semantic request descriptions, including text, voice, and files; Hierarchical intent recognition is performed on the semantic request description. A task dependency directed acyclic graph is constructed through recursive decomposition and dependency relationship recognition. Based on the topological sorting result of the task dependency directed acyclic graph, a task plan is generated. Based on the current semantic request description, an enhanced contextual representation is generated by combining the sliding window management of short-term memory with the semantic vector retrieval of long-term memory. By combining task planning and enhanced contextual representation, the corresponding reasoning mode is adaptively selected and executed for each task. The reasoning mode includes the thought chain reasoning mode, the action-observation loop, and the fusion mode. The tool is encapsulated using a pre-defined model context standard protocol, and a dynamic registration and scheduling management mechanism for tool capabilities is built through a skill registry center; Based on the dynamic registration and scheduling management mechanism of tool capabilities, the task execution results are aggregated, organized, and uniformly formatted, and the formatted results are returned to the user to realize the construction of business intelligence agents.

2. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 1, characterized in that, The hierarchical intent recognition performed on the semantic request description, constructing a task dependency directed acyclic graph (DAG) through recursive decomposition and dependency identification, and generating task planning based on the topological sorting result of the DAG, includes: Using a pre-trained domain classification model, semantic request descriptions are mapped to predefined business domain categories, and the corresponding domain labels and confidence scores are output. Based on domain labels and confidence scores, an explicit intent structure is constructed, and a chain-thinking reasoning method is used to perform semantic analysis on the semantic request description to generate an implicit intent list in order to obtain the fusion request. The fusion request is analyzed, and a task sequence is generated based on the analysis results through a recursive decomposition strategy. A directed acyclic graph of task dependencies is constructed according to the preset dependency identification rules. Based on the topological sorting results of the task-dependent directed acyclic graph, and combined with the capability description information of the agent and the tool, a greedy scheduling algorithm is used to generate a task plan.

3. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 2, characterized in that, The process involves constructing an explicit intent structure based on domain labels and confidence scores, and then using chain-like reasoning to perform semantic analysis on the semantic request description to generate an implicit intent list, thereby obtaining the fusion request, which includes: Based on domain labels and confidence scores, target slots are extracted from semantic request descriptions using a pre-defined sequence labeling model to construct an explicit intent structure. Based on the chain-like reasoning method, a prompt template containing the reasoning chain is constructed, and the prompt template is used to guide the preset large language model to perform semantic analysis on the semantic request description and generate an implicit intent list. By combining the explicit intent structure and the implicit intent list, the semantic request description is updated, and a fused request is generated based on the update result.

4. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 3, characterized in that, The process of analyzing the fusion request, generating a task sequence based on the analysis results using a recursive decomposition strategy, and constructing a directed acyclic graph of task dependencies according to preset dependency identification rules includes: Analyze the number of action types, the number of objects being operated on, and the number of entries in the implicit intent list in the fusion request, and determine whether the fusion request is a composite request based on the analysis results; If it is determined to be a composite request, recursive decomposition is performed to generate a task set, and the dependency and constraint relationships between tasks are identified according to the preset dependency identification rules to construct a directed acyclic graph of task dependencies. If the request is determined to be non-composite, the fusion request will be treated as a single task, and a task dependency directed acyclic graph containing only a single task node will be constructed.

5. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 4, characterized in that, The recursive decomposition process generates a task set, including: Based on the action type, the fusion request is initially decomposed to generate multiple sub-requests, and the operation objects in the sub-requests are further decomposed. Using a pre-defined large language model, the execution complexity of the sub-requests after the second decomposition is evaluated. If the execution complexity exceeds a preset threshold, a third decomposition is performed, and the complexity evaluation and decomposition operations are repeated until the preset recursion termination condition is reached, generating a task set. If the execution complexity does not exceed the preset threshold, a task set is generated directly.

6. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 1, characterized in that, The process of generating an enhanced context representation based on the current semantic request description, combined with sliding window management of short-term memory and semantic vector retrieval of long-term memory, includes: Based on the current semantic request description and the historical semantic request description, an updated short-term memory is generated using sliding window and dynamic summarization techniques; By combining the current semantic request description with the updated short-term memory, semantic vector retrieval is performed from the pre-built vector knowledge base to obtain long-term memory retrieval results; The current semantic request description, the updated short-term memory and long-term memory retrieval results are fused with attention weighting to generate an enhanced contextual representation.

7. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 6, characterized in that, The step of generating an updated short-term memory based on the current semantic request description and the historical semantic request description, using sliding window and dynamic summarization techniques, includes: Set the maximum context window length to the preset target token number, and use the current semantic request description and the historical semantic request description as a dialogue round queue to initialize short-term memory; During the dialogue interaction, after each round of dialogue is completed, a new dialogue round is added to the end of the dialogue round queue, and the number of tokens for all rounds in the dialogue round queue is calculated. Determine if the number of tokens exceeds the preset target number of tokens. If so, retrieve the earliest round to be compressed from the head of the dialogue round queue, concatenate the rounds to be compressed into text, input it into the preset summary generation model, output the summary text and encapsulate it into a summary entry, insert it into the head of the dialogue round queue, and generate the updated short-term memory. If not, generate the updated short-term memory based on the current dialogue round queue.

8. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 1, characterized in that, The method combines task planning and enhanced contextual representation to adaptively select and execute corresponding reasoning modes for each task. These reasoning modes include a thought chain reasoning mode, an action-observation loop, and a fusion mode. Based on task planning and enhanced contextual representation, each task is evaluated, and the corresponding reasoning mode is selected based on the evaluation results. The reasoning modes include thought chain reasoning mode, action observation loop and fusion mode. Based on the selected inference mode, the task scheduling and inference operations are executed, and the format verification, logic verification and integrity verification are performed on the execution result of each step in sequence. If the verification passes, the subsequent inference process continues; if the verification fails, the dynamic replanning mechanism is triggered to adjust the inference mode.

9. The method for constructing multi-agent collaborative dialogue-as-a-service business intelligent agents according to claim 8, characterized in that, The process involves evaluating each task based on task planning and enhanced contextual representation, and selecting a corresponding reasoning mode based on the evaluation results. These reasoning modes include a thought chain reasoning mode, an action-observation loop, and a fusion mode. The complexity characteristics of each task are evaluated and analyzed. These complexity characteristics include reasoning depth, tool dependence, and information timeliness. If the task only involves logical reasoning and does not involve tool usage, then select the thought chain reasoning mode; If the task aims to utilize tools and uses logical reasoning as an aid, then select the action observation loop mode; If the task includes both logical reasoning and tool invocation, then a fusion mode that combines the thinking chain reasoning mode and the action observation loop mode is selected. In the fusion mode, the observation results of the action nodes are fed back to the subsequent reasoning nodes in real time.

10. A multi-agent collaborative dialogue-as-a-service business intelligent agent construction system, characterized in that, The system includes: The request receiving and encoding module is used to receive dialogue requests submitted by users and encode the dialogue requests into standardized semantic request descriptions, including text, voice, and files. The task decomposition and planning module is used to perform hierarchical intent recognition on semantic request descriptions. It constructs a task dependency directed acyclic graph by recursive decomposition and dependency recognition, and generates task planning based on the topological sorting results of the task dependency directed acyclic graph. The context enhancement module is used to generate an enhanced context representation based on the current semantic request description, combining the sliding window management of short-term memory with the semantic vector retrieval of long-term memory; The reasoning mode selection module is used to combine task planning and enhanced context representation to adaptively select and execute the corresponding reasoning mode for each task. The reasoning modes include the thought chain reasoning mode, the action observation loop, and the fusion mode. The tool dynamic management module is used to encapsulate tools using a preset model context standard protocol and to build a dynamic registration and scheduling management mechanism for tool capabilities through the skill registry center. The results aggregation and delivery module is used to aggregate, organize, and uniformly format task execution results based on the tool's dynamic registration and scheduling management mechanism, and return the formatted results to the user to realize the construction of business intelligence agents.

Images