Intelligent agent capability integration and execution method based on multi-protocol interpreter

Abstract

The invention relates to the technical field of intelligent agent capability docking protocols, in particular to an intelligent agent capability integration and execution method based on a multi-protocol interpreter. The invention relates to an interpreter, which is applied to an intelligent agent, enables a single intelligent agent or an intelligent agent system to seamlessly understand, convert and execute instructions or capability calling requests from different protocols (such as MCP, A2A and the like), is used as a protocol universal interface of the intelligent agent, uniformly analyzes external multi-protocol input into an internal executable capability graph, and dynamically schedules and executes the internal executable capability graph.

Description

Technical Field

[0001] This invention relates to the technical field of intelligent agent capability interoperability protocols, and in particular to a method for intelligent agent capability integration and execution based on a multi-protocol interpreter. Background Technology

[0002] To expand the capabilities of intelligent agents, various AI vendors are currently customizing their own protocols, such as MCP, A2A, and functionCall. Each of these protocols has its own limitations, and developers need to learn and master the standards of each vendor's protocol.

[0003] MCP primarily focuses on standardized interactions between models and applications, emphasizing the specifications for models calling external tools. A2A, on the other hand, focuses on communication and collaboration between agents, achieving collaboration through three basic interaction units: tasks, artifacts, and messages.

[0004] Therefore, a smart agent protocol compatible with protocols such as MCP, A2A, and fusionCall is needed, so that developers can achieve the goal of infinitely expanding the capabilities of smart agents by mastering only one protocol, and complete the configuration of smart agent capabilities with one protocol. Summary of the Invention

[0005] The purpose of this invention is to provide a method for integrating and executing intelligent agent capabilities based on a multi-protocol interpreter, in order to solve the problem that existing technologies for customizing protocols to extend intelligent agent capabilities each have their own limitations, and developers need to learn and master the protocol standards of various manufacturers.

[0006] To achieve the above objectives, the present invention provides the following technical solution: a method for integrating intelligent agent capabilities based on a multi-protocol interpreter, which enables the acceptance of requests from different protocols based on an MCP client and an A2A intelligent agent, specifically including the following steps:

[0007] Step S1: Construct a protocol adaptation layer to listen for requests from at least MCP and A2A protocols, understand the unique syntax, data structure and semantics of different protocols, perform preliminary processing on inputs of different formats, and prepare for conversion into a unified format.

[0008] Step S2: Receive standardized information from the protocol adaptation layer through the unified intermediate representation generator, extract its core elements, and generate a unified internal instruction IR that is independent of the specific protocol. The internal instruction IR includes intent, parameters, and context information.

[0009] Step S3: Establish a capability matcher and fusion unit, receive a unified IR, and then find the best combination of capabilities to complete the intention among the capability units registered within the agent. If a task requires the simultaneous use of MCP tools and A2A collaboration, the matching and fusion mechanism will combine capabilities from different protocol sources into a new, collaborative workflow.

[0010] Step S4: Establish a dynamic executor, receive the task flow diagram planned by the capability matching and fusion unit, construct a dynamic capability graph in the form of a directed acyclic graph (DAG) based on the task dependencies, and be responsible for scheduling, execution and fault tolerance.

[0011] Step S5: Establish a result formatter and distributor, receive the final result of the dynamic executor, and then: convert the internally unified processing result back to the protocol format followed by the original request, and then accurately send the formatted result back to the original requester (MCP client or A2A agent).

[0012] Preferably, the MCP client is a client that follows the Model Context Protocol and mainly requests to invoke tools or obtain resources, while the A2A agent is another agent that follows the Agent-to-Agent protocol and mainly requests to cooperate, negotiate, or share tasks.

[0013] Preferably, the unified intermediate representation is generated through the following process:

[0014] Extract the task intent from the protocol message to form a standardized intent identifier;

[0015] Extract parameter information from the protocol message to form a set of parameter key-value pairs;

[0016] Extract context information from protocol messages, including session history and permission information;

[0017] The intent, parameters, and context information are combined into structured intermediate representation data.

[0018] Preferably, the scheduling, execution, and fault tolerance of the dynamic actuator specifically include:

[0019] Scheduling: Determine the execution order of each node in the graph and identify tasks that can be executed in parallel;

[0020] Execution: Trigger the execution of each capability unit in sequence according to the dependency relationship, and manage the flow of data between nodes;

[0021] Fault tolerance: Handling errors or exceptions that may occur during execution.

[0022] A method for executing agent capabilities based on a multi-protocol interpreter includes the following steps:

[0023] Receive the capability matching result processed by the intelligent agent capability integration method based on the multi-protocol interpreter;

[0024] Based on the matching and fusion results, a dynamic capability execution graph is constructed, wherein the execution graph is a directed acyclic graph structure;

[0025] The capability units are scheduled and executed according to the execution graph by a dynamic actuator;

[0026] Manage the transmission and status monitoring of intermediate results during execution;

[0027] The final execution result is converted into the original request protocol format using the result formatter and returned.

[0028] Preferably, the construction of the dynamic capability execution graph includes:

[0029] Initialize the capability graph (G=(V,E)), where (V) are capability nodes and (E) are data flow edges;

[0030] For each matching capability node (N_i), determine its input dependencies: [

[0032] \text{Dependency}(N_i)={N_j|N_j.output\capN_i.input\neq\emptyset} ]

[0034] Topological sorting is used to determine the execution order, and parallel node identification is supported;

[0035] Execution is data-driven: execution is triggered when all inputs to a node are ready.

[0036] Preferably, the execution process employs a data flow-driven mechanism:

[0037] Monitor the input data readiness status of each capability node;

[0038] When all the input data for a node is ready, the execution of that node is automatically triggered;

[0039] During execution, the node status is monitored in real time, and execution exceptions are handled.

[0040] After a node completes its execution, it passes the output to its downstream dependent nodes.

[0041] Preferably, the result formatting process includes:

[0042] Identify the protocol type of the original request;

[0043] Convert the internally unified processing results into the data format of the target protocol;

[0044] Encapsulate the result data according to the response specifications of the target protocol;

[0045] The formatted result is returned to the corresponding requester.

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

[0047] 1. Unified IR design: Convert MCP tool calls, A2A collaborative messages, etc. into a unified intermediate representation to mask protocol differences.

[0048] 2. Dynamic Capability Graph: Dynamically builds and optimizes the execution flowchart based on real-time task requirements, supporting complex task orchestration.

[0049] 3. Cross-protocol capability integration: Allows capability units from different protocols to be combined into new capabilities, achieving a synergistic effect of "1+1>2".

[0050] 4. Performance Measurement Model: Proposes quantitative indicators such as protocol uniformity and collaboration gain for system self-evaluation and optimization. Attached Figure Description

[0051] Figure 1 This is a schematic diagram of the overall implementation architecture of the present invention;

[0052] Figure 2 This is a schematic diagram of the execution flow of the protocol of this invention. Detailed Implementation

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

[0054] Please see Figure 1-2 This invention provides a technical solution: a method for integrating intelligent agent capabilities based on a multi-protocol interpreter, which enables the acceptance of requests from different protocols based on an MCP client and an A2A intelligent agent, specifically including the following steps:

[0055] Step S1: Construct a protocol adaptation layer to listen for requests from at least MCP and A2A protocols, understand the unique syntax, data structure and semantics of different protocols, perform preliminary processing on inputs of different formats, and prepare for conversion into a unified format.

[0056] Step S2: Receive standardized information from the protocol adaptation layer through the unified intermediate representation generator, extract its core elements, and generate a unified internal instruction IR that is independent of the specific protocol. The internal instruction IR includes intent, parameters, and context information.

[0057] The algorithm for generating a unified intermediate representation across multiple protocols is as follows:

[0058] Input: Protocol message (M_p) (from protocol (p))

[0059] Output: Unified Intermediate Representation (IR) [

[0061] IR=\text{ExtractIntent}(M_p)\oplus\text{ExtractParams}(M_p)\oplus\text{ExtractContext}(M_p) ]

[0063] in:

[0064] (\text{ExtractIntent}): Extracts the task intent (e.g., "query_weather", "collaborate_plan").

[0065] (\text{ExtractParams}): Extracts parameter key-value pairs.

[0066] (\text{ExtractContext}): Extracts session context, permissions, etc.

[0067] (\oplus): Indicates splicing or structural combination;

[0068] Step S3: Establish a capability matcher and fusion unit, receive a unified IR, and then find the best combination of capabilities to complete the intention among the capability units registered within the agent. If a task requires the simultaneous use of MCP tools and A2A collaboration, the matching and fusion mechanism will combine capabilities from different protocol sources into a new, collaborative workflow.

[0069] The capability matching and fusion algorithm is as follows:

[0070] definition:

[0071] Capability Unit (C_i=(name,input_schema,output_schema,protocol_type,func))

[0072] Capability graph node (N_j=(C_j,input_from,output_to))

[0073] Matching process: [

[0075] \text{MatchScore}(IR,C_i)=\alpha\cdot\text{SemanticSim}(IR.intent,C_i.name)+\beta\cdot\text{SchemaCompat}(IR.params,C_i.input_schema) ]

[0077] Fusion rules (multi-protocol collaboration):

[0078] If (\existsC_a\in\text{MCP_Capabilities},C_b\in\text{A2A_Capabilities}) and the task requires collaboration: [

[0080] C_{fused}=\text{MergeCapabilities}(C_a,C_b) ]

[0082] The input of the merged capability is (C_a.input\cupC_b.input), and the output is the merged or concatenated result;

[0083] Step S4: Establish a dynamic executor, receive the task flow diagram planned by the capability matching and fusion unit, construct a dynamic capability graph in the form of a directed acyclic graph (DAG) based on the task dependencies, and be responsible for scheduling, execution and fault tolerance.

[0084] Step S5: Establish a result formatter and distributor, receive the final result of the dynamic executor, and then: convert the internally unified processing result back to the protocol format followed by the original request, and then accurately send the formatted result back to the original requester (MCP client or A2A agent).

[0085] Furthermore, the MCP client is a client that follows the ModelContextProtocol protocol and mainly requests to invoke tools or obtain resources, while the A2A agent is another agent that follows the Agent-to-Agent protocol and mainly requests to cooperate, negotiate, or share tasks.

[0086] Furthermore, the unified intermediate representation is generated through the following process:

[0087] Extract the task intent from the protocol message to form a standardized intent identifier;

[0088] Extract parameter information from the protocol message to form a set of parameter key-value pairs;

[0089] Extract context information from protocol messages, including session history and permission information;

[0090] Combine intent, parameters, and contextual information into structured intermediate representation data.

[0091] Furthermore, the scheduling, execution, and fault tolerance of dynamic executors specifically include:

[0092] Scheduling: Determine the execution order of each node in the graph and identify tasks that can be executed in parallel;

[0093] Execution: Trigger the execution of each capability unit in sequence according to the dependency relationship, and manage the flow of data between nodes;

[0094] Fault tolerance: Handling errors or exceptions that may occur during execution.

[0095] A method for executing agent capabilities based on a multi-protocol interpreter includes the following steps:

[0096] Receive the capability matching results processed by the agent capability integration method based on a multi-protocol interpreter;

[0097] Based on the matching and fusion results, a dynamic capability execution graph is constructed, which is a directed acyclic graph structure.

[0098] The capability units are scheduled and executed according to the execution graph by a dynamic actuator;

[0099] Manage the transmission and status monitoring of intermediate results during execution;

[0100] The final execution result is converted into the original request protocol format using the result formatter and returned.

[0101] Furthermore, the construction of the dynamic capability execution graph includes:

[0102] Initialize the capability graph (G=(V,E)), where (V) are capability nodes and (E) are data flow edges;

[0103] For each matching capability node (N_i), determine its input dependencies: [

[0105] \text{Dependency}(N_i)={N_j|N_j.output\capN_i.input\neq\emptyset} ]

[0107] Topological sorting is used to determine the execution order, and parallel node identification is supported;

[0108] Execution is data-driven: execution is triggered when all inputs to a node are ready.

[0109] Furthermore, the execution process employs a data flow-driven mechanism:

[0110] Monitor the input data readiness status of each capability node;

[0111] When all the input data for a node is ready, the execution of that node is automatically triggered;

[0112] During execution, the node status is monitored in real time, and execution exceptions are handled.

[0113] After a node completes its execution, it passes the output to its downstream dependent nodes.

[0114] Furthermore, the result formatting process includes:

[0115] Identify the protocol type of the original request;

[0116] Convert the internally unified processing results into the data format of the target protocol;

[0117] Encapsulate the result data according to the response specifications of the target protocol;

[0118] The formatted result is returned to the corresponding requester.

[0119] The execution of the protocol is handled by a protocol interpreter, which will be implemented in various programming languages, such as Node.js, .NET, Python, and Java. When an instruction enters the protocol interpreter, the interpreter first analyzes the semantics of the instruction to see if a matching, already integrated agent capability is found. If found, the instruction's parameters are analyzed to extract the parameter content. The parameters and capabilities are then sent to the execution pipeline, where different processing methods, such as MPC and A2A, are invoked based on the integrated capability.

[0120] The data structure of the protocol is shown in the table below:

[0121] Fields name describe name Ability Name Define the name of a capability prompt Prompt words The description of a capability tells the agent when it is needed. negprompt Reverse prompt words The reverse description of a capability tells the agent when not to use that capability. arguments parameter[] The parameters required to invoke this capability are an array type, and multiple parameters can be configured. arguments - name Parameter name arguments - type Parameter type arguments - desc Parameter description type Ability Type Which type of implementation capability does it belong to, such as MCP, A2A, or custom implementation?

[0122] Example

[0123] Scenario: A user requests to "plan a team business trip" through the MCP protocol, which involves flight inquiry (MCP tool) and team member coordination (A2A protocol).

[0124] The MCP interpreter receives the request and generates the IR: {intent: "plan_business_trip", members: ["Alice","Bob"], date: "2025-11-10"}.

[0125] Ability matching: Matched to "Flight Search" (MCP) and "Team Schedule Coordination" (A2A).

[0126] Build a capability graph:

[0127] Node 1 (A2A): Collects the available time of members;

[0128] Node 2 (MCP): Query flights;

[0129] Node 3 (MCP+A2A): Generates a plan based on time and flight schedule, and sends confirmation;

[0130] Execute and return the integration results.

[0131] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for integrating the capabilities of intelligent agents based on a multi-protocol interpreter, characterized in that, To enable the acceptance of requests from different protocols using an MCP client and an A2A agent, the specific steps include: Step S1: Construct a protocol adaptation layer to listen for requests from at least MCP and A2A protocols, understand the unique syntax, data structure and semantics of different protocols, perform preliminary processing on inputs of different formats, and prepare for conversion into a unified format. Step S2: Receive standardized information from the protocol adaptation layer through the unified intermediate representation generator, extract its core elements, and generate a unified internal instruction IR that is independent of the specific protocol. The internal instruction IR includes intent, parameters, and context information. Step S3: Establish a capability matcher and fusion unit, receive a unified IR, and then find the best combination of capabilities to complete the intention among the capability units registered within the agent. If a task requires the simultaneous use of MCP tools and A2A collaboration, the matching and fusion mechanism will combine capabilities from different protocol sources into a new, collaborative workflow. Step S4: Establish a dynamic executor, receive the task flow diagram planned by the capability matching and fusion unit, construct a dynamic capability graph in the form of a directed acyclic graph (DAG) based on the task dependencies, and be responsible for scheduling, execution and fault tolerance. Step S5: Establish a result formatter and distributor, receive the final result of the dynamic executor, and then: convert the internally unified processing result back to the protocol format followed by the original request, and then accurately send the formatted result back to the original requester (MCP client or A2A agent).

2. The method for integrating intelligent agent capabilities based on a multi-protocol interpreter according to claim 1, characterized in that, The MCP client is a client that follows the Model Context Protocol and mainly requests to invoke tools or obtain resources. The A2A agent is another agent that follows the Agent-to-Agent protocol and mainly requests to cooperate, negotiate, or share tasks.

3. The method for integrating intelligent agent capabilities based on a multi-protocol interpreter according to claim 1, characterized in that, The unified intermediate representation is generated through the following process: Extract the task intent from the protocol message to form a standardized intent identifier; Extract parameter information from the protocol message to form a set of parameter key-value pairs; Extract context information from protocol messages, including session history and permission information; The intent, parameters, and context information are combined into structured intermediate representation data.

4. The method for integrating intelligent agent capabilities based on a multi-protocol interpreter according to claim 1, characterized in that, The scheduling, execution, and fault tolerance of the dynamic actuator specifically include: Scheduling: Determine the execution order of each node in the graph and identify tasks that can be executed in parallel; Execution: Trigger the execution of each capability unit in sequence according to the dependency relationship, and manage the flow of data between nodes; Fault tolerance: Handling errors or exceptions that may occur during execution.

5. A method for executing intelligent agent capabilities based on a multi-protocol interpreter, characterized in that, Includes the following steps: Receive the capability matching result processed by the agent capability integration method based on a multi-protocol interpreter as described in any one of claims 1-4; Based on the matching and fusion results, a dynamic capability execution graph is constructed, wherein the execution graph is a directed acyclic graph structure; The capability units are scheduled and executed according to the execution graph by a dynamic actuator; Manage the transmission and status monitoring of intermediate results during execution; The final execution result is converted into the original request protocol format using the result formatter and returned.

6. The method for executing intelligent agent capabilities based on a multi-protocol interpreter according to claim 5, characterized in that, The construction of the dynamic capability execution graph includes: Initialize the capability graph (G=(V,E)), where (V) are capability nodes and (E) are data flow edges; For each matching capability node (N_i), determine its input dependencies: [ \text{Dependency}(N_i)={N_j|N_j.output\capN_i.input\neq\emptyset} ] Topological sorting is used to determine the execution order, and parallel node identification is supported; Execution is data-driven: execution is triggered when all inputs to a node are ready.

7. The method for executing intelligent agent capabilities based on a multi-protocol interpreter according to claim 5, characterized in that, The execution process employs a data flow-driven mechanism: Monitor the input data readiness status of each capability node; When all the input data for a node is ready, the execution of that node is automatically triggered; During execution, the node status is monitored in real time, and execution exceptions are handled. After a node completes its execution, it passes the output to its downstream dependent nodes.

8. The method for executing intelligent agent capabilities based on a multi-protocol interpreter according to claim 5, characterized in that, The result formatting process includes: Identify the protocol type of the original request; Convert the internally unified processing results into the data format of the target protocol; Encapsulate the result data according to the response specifications of the target protocol; The formatted result is returned to the corresponding requester.

Images