A development system and method for an enterprise data integration agent

Abstract

The application discloses a kind of enterprise data integration intelligent agent's development system and method.The system includes: data acquisition module obtains multi-format enterprise data;Data processing module pre-processes data and constructs first and second intelligent agents, first intelligent agent batch processing data obtains first and second data, encapsulates first data as first data group, and outputs second data to second intelligent agent to batch processing obtains second data group as translation backup;Data update module extracts two data group snapshots to compare differences, converts into difference compensation features, maps to intelligent agent update configuration item according to preset time period to realize cross iteration, and independently updates configuration when new data is written.The present application realizes cross iteration by heterogeneous translation backup and difference compensation, and guarantees the high availability and dynamic self-adaptive update of data integration under the cooperation of multiple intelligent agents.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, specifically to a development system and method for an enterprise data integration intelligent agent. Background Technology

[0002] As large language model technology is increasingly used in enterprise applications, agents have become an important vehicle for handling complex business processes and knowledge management. However, enterprises continuously generate multi-source heterogeneous data in actual operations, and existing data integration methods mostly rely on traditional ETL pipelines or hard-coded configurations, which are difficult to adapt to the direct calling requirements of large language models for structured and semantic data.

[0003] Meanwhile, existing agent development frameworks have significant shortcomings in multi-agent collaboration and data state management. On the one hand, most existing systems are single-agent architectures or simple multi-agent stacks, lacking data translation and heterogeneous backup mechanisms between agents. When processing massive amounts of enterprise data, they are highly susceptible to business interruptions and state inconsistencies due to single points of failure or data drift. On the other hand, when faced with agent configuration iterations and continuous new data writing, existing solutions typically employ a single global update mechanism, leading to mutual blocking of update tasks and chaotic context management rules.

[0004] Therefore, how to provide a development system and method that can efficiently integrate enterprise data in multiple formats, ensure high data availability through multi-agent translation and backup, perform cross-iterative updates based on data differences, and achieve independent and accurate responses when new data is written has become a technical problem that urgently needs to be solved in this field. Summary of the Invention

[0005] To address the above problems, this invention provides a development system and method for enterprise data integration intelligent agents.

[0006] A first aspect of the present invention provides a development system for an enterprise data integration intelligent agent, comprising: The data acquisition module is configured to acquire enterprise data in multiple formats; The data processing module is configured to preprocess the enterprise data and map the enterprise data to a preset enterprise ontology model to obtain multiple standard enterprise ontology data layers. The intelligent agent construction module is configured to generate multiple enterprise intelligent agents based on the standard enterprise ontology data layer. Each enterprise intelligent agent includes an encapsulated coded file, which encapsulates an intelligent agent identity identifier, a tool calling interface, context management rules, and workflow logic. The data update module is configured to execute a response when new enterprise data is written to the system, remapping the enterprise data to the corresponding enterprise intelligent body and updating the configuration in the coded file.

[0007] As a preferred embodiment, the data processing module is specifically configured as follows: The multi-modal parsing engine preprocesses the multi-format enterprise data and identifies file types, extracting entity fields, attribute parameters, and business relationships from the enterprise data. Based on the enterprise's ontology requirements, an ontology schema is constructed that includes business entity definitions, hierarchical relationship constraints, and permission boundaries. The extracted entity fields, attribute parameters, and business relationships are aligned and disambiguated with the ontology schema and mapped to the preset enterprise ontology model to obtain the multiple standard enterprise ontology data layers.

[0008] As a preferred embodiment, the agent construction module is specifically configured as follows: Based on the interface call specification of the large language model, the entity relationships in the standard enterprise ontology data layer are transformed into structured tool definition descriptions; Based on the characteristics of agent creation, configure the memory storage path, session context window strategy and exception rollback mechanism for the corresponding enterprise agent; The tool definition description, memory storage path, session context window strategy, and exception rollback mechanism are serialized and encapsulated with the agent identity to generate the coded file. The coded file adopts JSON or YAML format, and its internal index path is directly bound to the vector retrieval engine or function call protocol of the large language model.

[0009] As a preferred embodiment, the data update module specifically includes an event listening unit, an incremental processing unit, and a version synchronization unit; The event listening unit is configured to monitor the write status of the data access channel in real time. When new enterprise data is detected being written to the system, a write trigger signal is generated, and the corresponding enterprise intelligent agent's call request for the old data version is temporarily suspended. The incremental processing unit is configured to respond to the write trigger signal, parse the metadata identifier of the new enterprise data, perform differential comparison and dependency recalculation between the new enterprise ontology model and the preset enterprise ontology model, and generate incremental mapping results. The version synchronization unit is configured to remap the incremental mapping result to the corresponding enterprise intelligent body, hot update the corresponding configuration in the codeable file, and release the suspended state after the update is completed, so that the corresponding enterprise intelligent body can respond to external requests based on the updated codeable file.

[0010] As a preferred approach, a consistency verification module is also included, which is configured to perform syntax structure verification, tool call link connectivity verification, and data integrity verification on the updated codeable file after the version synchronization unit completes the hot update. If the verification passes, the updated status is published to the large language model scheduler. If the verification fails, a rollback instruction is triggered to restore the corresponding coded file to the previous stable version before the update.

[0011] A second aspect of the present invention provides a method for developing an enterprise data integration intelligent agent, comprising the following steps: Includes the following steps: Acquire enterprise data in multiple formats; The enterprise data is preprocessed and mapped to a preset enterprise ontology model to obtain multiple standard enterprise ontology data layers; Multiple enterprise intelligent agents are generated based on the standard enterprise ontology data layer. Each enterprise intelligent agent includes an encapsulated coded file, which encapsulates the intelligent agent's identity identifier, tool call interface, context management rules, and workflow logic. When new enterprise data is written to the system, a response is executed to remap the enterprise data to the corresponding enterprise intelligent body and update the configuration in the coded file.

[0012] As a preferred approach, the enterprise data is preprocessed and mapped to a preset enterprise ontology model to obtain multiple standard enterprise ontology data layers, specifically including: The multi-modal parsing engine preprocesses the multi-format enterprise data and identifies file types, extracting entity fields, attribute parameters, and business relationships from the enterprise data. Construct an ontology schema based on the enterprise's ontology requirements, including business entity definitions, hierarchical relationship constraints, and permission boundaries; The extracted entity fields, attribute parameters, and business relationships are aligned and disambiguated with the ontology schema and mapped to the preset enterprise ontology model to obtain the multiple standard enterprise ontology data layers.

[0013] As a preferred approach, multiple enterprise intelligent agents are generated based on the standard enterprise ontology data layer, specifically including: Based on the interface call specification of the large language model, the entity relationships in the standard enterprise ontology data layer are transformed into structured tool definition descriptions; Based on the characteristics of agent creation, the memory storage path, session context window policy, and exception rollback mechanism of the corresponding enterprise agent are configured; the tool definition description, memory storage path, session context window policy, and exception rollback mechanism are serialized and encapsulated with the agent identity to generate the coded file, wherein the coded file adopts JSON or YAML format, and its internal index path is directly bound to the vector retrieval engine or function call protocol of the large language model.

[0014] As a preferred approach, the execution response remaps the enterprise data to the corresponding enterprise intelligent entity and updates the configuration in the encodeable file, specifically including: The system monitors the write status of the data access channel in real time. When new enterprise data is detected being written to the system, a write trigger signal is generated, and the corresponding enterprise intelligent agent's request to call the old data version is temporarily suspended. In response to the write trigger signal, the metadata identifier of the new enterprise data is parsed, the differential comparison and dependency recalculation between the new enterprise ontology model and the preset enterprise ontology model are performed, and an incremental mapping result is generated. The incremental mapping result is remapped to the corresponding enterprise intelligent body, and the corresponding configuration in the codeable file is hot-updated. After the update is completed, the suspended state is released, and the corresponding enterprise intelligent body responds to external requests based on the updated codeable file.

[0015] As a preferred approach, after remapping the incremental mapping result to the corresponding enterprise intelligence entity and hot-updating the corresponding configuration in the coded file, the method further includes: Perform syntax structure verification, tool call link connectivity verification, and data integrity verification on the updated codec file; if the verification passes, publish the update status to the large language model scheduler. If the verification fails, a rollback instruction is triggered to restore the corresponding coded file to the previous stable version before the update.

[0016] Compared with the prior art, the present invention has the following advantages: This invention achieves structured encapsulation and heterogeneous backup of multi-format enterprise data at the agent level by constructing at least a first agent and a second agent. The first agent batch processes enterprise data to obtain a first data set, while simultaneously outputting data to the second agent to generate a second data set as a translation backup. This mechanism not only enables enterprise data to directly adapt to the calling protocol of large language models, lowering the deployment and integration threshold of agents, but also effectively avoids single-point data failures or state drift through translation backup, significantly improving the high availability and fault tolerance of system data integration.

[0017] This invention, through the first configuration of the data update module, extracts snapshots of the first and second data groups respectively, compares the data differences, transforms the data differences into structured difference compensation features, and maps them to the first and second intelligent agents according to a preset time period to update the configuration items of the coded file. This mechanism can accurately capture subtle data differences caused by changes in data volume during batch processing by multiple agents. Through periodic cross-iterative updates, it automatically compensates for and corrects the context management rules and workflow logic of the agents, ensuring data consistency in a multi-node collaborative state and avoiding the computational resource consumption and response delay caused by traditional full reconstruction.

[0018] This invention, through a second configuration of the data update module, independently executes a response and writes the new enterprise data into the first data group to update the configuration items of the coded file when new enterprise data is written to the system within a preset time period. This mechanism achieves real-time and accurate response and local incremental updates when new data is injected. Moreover, this real-time update process is independent of the periodic cross-iteration process of the first configuration, effectively avoiding mutual blocking and logical interference between background iteration tasks and front-end real-time writing tasks, and ensuring the agent's high concurrency processing capability, real-time performance, and version management stability in dynamic data environments. Attached Figure Description

[0019] The present invention will be further described with reference to the accompanying drawings, but the embodiments in the drawings do not constitute any limitation on the present invention. For those skilled in the art, other drawings can be obtained based on the following drawings without creative effort.

[0020] Figure 1 This is a structural block diagram of the system provided in the embodiments of the present invention. Detailed Implementation

[0021] 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.

[0022] In one specific embodiment of the present invention, a development system for an enterprise data integration intelligent agent is provided, such as... Figure 1 As shown. This system aims to address the difficulties in integrating multi-source heterogeneous data, the lack of data translation and backup mechanisms between agents, and the problems of mutual blocking of update tasks and chaotic context management when facing data iteration and new data writing in existing agent development frameworks. It achieves efficient integration of enterprise data and highly available dynamic updates under multi-agent collaboration. The system specifically includes the following modules: The data acquisition module is configured to acquire enterprise data in multiple formats. Specifically, this multi-format enterprise data includes, but is not limited to, structured forms in relational databases, semi-structured text in log files, and unstructured documents in the enterprise knowledge base.

[0023] The data processing module is configured to preprocess enterprise data and construct at least a first and a second intelligent agent. Each intelligent agent includes a packaged, coded file containing configuration items such as agent identifier, tool call structure, context management rules, and workflow logic. Specifically, during preprocessing, the system cleans and unifies the formats of multi-format data; during agent construction, the prompt word templates, API interface definitions, and business flow logic of the large language model are serialized into JSON or YAML format and packaged to generate the aforementioned coded file. By encapsulating the coded file, enterprise data can be directly adapted to the function call and management protocols of the large language model, significantly reducing the deployment and integration threshold of the intelligent agents.

[0024] Specifically, the first intelligent agent is configured to batch process enterprise data to obtain first data and second data, encapsulate the first data to obtain a first data group, and output the second data to the second intelligent agent. The second intelligent agent is configured to batch process the received second data to obtain a second data group, and the second data group is a translated backup of the first data group. As a preferred embodiment, the division between the first data and the second data is based on the data usage dimension. For example, the first data consists of all core business features, while the second data consists of related context or summary features. The specific function of this translation and backup mechanism is that when the second intelligent agent batch processes the second data, it adopts a different data parsing engine or underlying storage structure than the first intelligent agent (such as translating relational data into a graph structure or vector structure), thereby achieving true heterogeneous backup at the physical and logical levels. This effectively avoids business interruptions caused by single-point data failures or single-format parsing errors, and significantly improves the high availability and fault tolerance of system data integration.

[0025] As a preferred embodiment, the establishment of the first and second snapshots is described below. Specifically, the system maintains a lightweight metadata pointer in the data write logs of the first and second data groups. When a snapshot needs to be extracted, the system only copies the metadata pointer and the corresponding data block index tree under the current timestamp, generating a read-only view containing the version timestamp and state hash value. Furthermore, to ensure the accuracy of the comparison between the first and second snapshots, the time-series snapshot method also includes a timestamp alignment mechanism. When generating the first and second snapshots, the system assigns the same time version tag to both snapshots through a global clock synchronization protocol and freezes data write operations after that timestamp (or routes them to a temporary buffer), thereby ensuring that the extracted first and second snapshots are absolutely consistent in the time dimension, avoiding false data differences due to time differences in data writes. This snapshot mechanism based on pointer offset, index tree copying, and timestamp alignment can complete snapshot construction within milliseconds, greatly reducing system I / O overhead and providing a high-purity prior benchmark for subsequent difference comparisons.

[0026] The data update module includes a first configuration and a second configuration. The first configuration is configured to extract a first snapshot and a second snapshot corresponding to a first data group and a second data group, respectively, compare the data differences between the two, convert the data differences into structured difference compensation features, and map the difference compensation features to the first intelligent agent and the second intelligent agent respectively according to a preset time period, thereby updating the configuration items of the coded file.

[0027] Specifically, when the data update module executes the first configuration, upon reaching the preset time period, it performs semantic vectorization processing on the data differences, extracting field offsets and relationship gaps caused by changes in data volume, and constructing difference compensation features that include compensation weights and update paths. As a preferred embodiment, the semantic vectorization processing is implemented as follows: text or structured fields in the data differences are converted into high-dimensional vectors, and the distance between vectors is calculated to accurately locate field offsets (such as changes in field types or numerical drift) and relationship gaps (such as the loss of relationships between entities). When constructing compensation weights, different weight values ​​are assigned according to the severity of the offsets and gaps; when constructing update paths, a routing table pointing to specific memory addresses is generated according to the configuration item hierarchy in the coded file. Subsequently, the difference compensation features are input into the context management rules of the first and second agents respectively. The first agent adjusts the batch processing node weights in its workflow logic based on the difference compensation features (e.g., increasing the verification weights for fields prone to offsets), and the second agent adjusts the verification thresholds of its translation backup based on the difference compensation features (e.g., dynamically relaxing or tightening the tolerance for consistency checks). The specific function of this mechanism is to accurately capture the subtle data differences caused by changes in data volume during batch processing of multiple agents. Through periodic cross-iteration updates, it automatically compensates for and corrects the context management rules of the agents, ensuring data consistency in the multi-node collaborative state and avoiding the consumption of computing resources caused by traditional full reconstruction.

[0028] Furthermore, to elucidate this difference compensation feature more deeply, its purpose, implementation method, and internal logic are elaborated in detail. Regarding its purpose, the difference compensation feature aims to address the issues of "state inconsistency" and "logic decay" caused by data distribution drift, semantic understanding bias, or differences in underlying translation structures when multiple agents continuously batch process heterogeneous data from multiple sources. Its core objective is to quantify and transform the abstract data inconsistency among multiple agents into executable optimization signals, thereby enabling the self-evolution and self-healing of the agent workflow. In terms of implementation, the system does not perform simple numerical comparisons but rather conducts deep semantic vectorization processing on the first and second snapshots. Specifically, the text or structured fields in the snapshots are mapped to a high-dimensional semantic space. By calculating the distance between vectors, the system accurately identifies field offsets (such as the overall distribution drift of specific entity attribute values) and relationship breaks (such as the loss of topological edge relationships between originally related business entities after translation backup) caused by changes in data volume or translation loss. Subsequently, the system assigns compensation weights based on the severity of offsets and breaks, and generates update paths pointing to specific memory addresses according to the configuration hierarchy of the coded files, ultimately encapsulating these into structured difference compensation features. Internally, this feature triggers a cross-iterative closed loop between the first and second agents: the first agent, as the source of data batch processing, adjusts its workflow logic based on the received difference compensation features, dynamically adjusting the weights of batch processing nodes (e.g., increasing feature extraction dimensions or verification frequency for fields with severe relationship breaks); the second agent, as the receiver of translation backups, adapts and calibrates based on the same difference compensation features, dynamically adjusting its translation backup verification thresholds (e.g., relaxing consistency tolerance for normal field offsets and tightening thresholds for abnormal drifts). This bidirectional cross-iterative logic based on the same difference source enables data producers and consumers to continuously reach new dynamic balances within a preset time period, achieving continuous alignment and leaps in the system's overall data cognition capabilities without manual intervention or full reconstruction.

[0029] Furthermore, mapping is specifically defined as: binding feature vectors or structured parameters from the source dataset to the memory address or index path of the corresponding configuration item within the coded file of the target agent, using a pre-defined transformation function or routing protocol, to obtain logical instructions. This mapping mechanism is particularly crucial in multi-agent collaborative scenarios. Specifically, the system maintains a global configuration mapping table through a pre-defined routing protocol. When difference compensation features need to be mapped to multiple target agents, the routing protocol distributes the feature vectors in parallel to the independent memory spaces of each target agent according to the global configuration mapping table. Simultaneously, a locking mechanism or lock-free concurrent queue ensures that the current workflow logic of the target agent is not unexpectedly interrupted when updating memory addresses or index paths. Because memory addresses or index paths are directly bound, the target agent can directly read and execute new logical instructions without re-parsing the massive data stream when loading the coded file in the next runtime cycle. This fast mapping method not only achieves millisecond-level hot configuration updates but also ensures efficient flow of cross-iterative updates among multiple agents, avoiding the network latency and parsing overhead associated with traditional configuration distribution.

[0030] The second configuration is set to execute a response when new enterprise data is written to the system within a preset time period, writing the new enterprise data to the first data group and updating the configuration items of the coded file.

[0031] Specifically, when the data update module executes the second configuration, it operates independently of the first configuration. Upon detecting new enterprise data being written to the system, it triggers an incremental write event. The new enterprise data is appended to the first data group, and a corresponding incremental data tag is generated synchronously. In a preferred embodiment, the incremental data tag generates a unique hash identifier based on the metadata (such as data type, source, and timestamp) of the newly written enterprise data. Based on the incremental data tag, the tool call structure in the first agent's coded file is partially updated. Specifically, the first agent identifies the external APIs or internal functions required by the new data based on the incremental data tag, dynamically modifying the parameter list or call order of the tool call structure in the coded file without recompiling or reloading the entire coded file. This mechanism enables real-time, accurate response and partial incremental updates when new data is injected, allowing the first agent to handle new types of data in a plug-and-play manner. Because this process is independent of the periodic cross-iteration of the first configuration, it effectively avoids mutual blocking and logical interference between background iteration tasks and front-end real-time write tasks, ensuring the agent's high-concurrency processing capability in dynamic data environments.

[0032] It should be noted that although the foregoing embodiments are described using the first and second intelligent agents as examples, the embodiments of the present invention can be seamlessly extended to multi-agent scenarios, and the two do not conflict. Specifically, the data processing module can construct the first to the Nth intelligent agents, where N is an integer greater than 2, and the data configuration modes between the intelligent agents include a first mode and a second mode. The system can dynamically switch or mix these two modes according to the sensitivity and business importance of the enterprise data. In the first mode, each intelligent agent performs sequential data backup, that is, the i-th intelligent agent outputs data to the (i+1)-th intelligent agent for translation and backup. This mode is suitable for core link data, can achieve chain-like data disaster recovery with low communication overhead, and ensures strict sequential consistency.

[0033] In the second mode, each agent performs cross-data backup, meaning that data from any agent is randomly output to another agent for backup. This mode is suitable for exploratory data analysis to improve disaster recovery flexibility. As a preferred embodiment, in the second mode, the data update module constructs a data flow topology map containing all agents and extracts data snapshots from any two agents that are backups of each other based on the randomly output path. It calculates the asymmetric data difference between the data snapshots of any two agents (i.e., the incomplete asymmetry of data states between the two agents due to the random output path) and transforms this asymmetric data difference into a cross-difference compensation feature with a flow direction identifier. According to a preset time period, the cross-difference compensation feature is mapped to the corresponding agent along the reverse path of the data flow topology map. During reverse path mapping, the system reverse-engineers the original data generation node based on the flow direction identifier and accurately returns the compensation feature to the agent primarily responsible for the data deviation. The specific function of this mechanism is to break the limitations of linear backup and, through mesh cross-backup and reverse path mapping, achieve responsibility tracing and accurate compensation among multiple nodes, greatly improving the robustness of multi-node cross-iterative updates in complex business networks.

[0034] Furthermore, when the number of agents N reaches a preset large data volume threshold, to overcome the computational bottleneck caused by multiple nodes, the data update module performs sharding processing on the data groups from the first agent to the Nth agent. Specifically, the sharding processing is based on the hash ring or time window of the data group to divide it into multiple data subsets, ensuring the integrity of each data subset in terms of business logic, and allocating an independent computing thread for each data subset. Within each computing thread, local snapshots of the corresponding data subset are extracted in parallel, local data differences are calculated, and local difference compensation features are generated. Distributed computing is used to reduce the dimensionality and fuse all local difference compensation features to obtain global difference compensation features. Specifically, dimensionality reduction and fusion can be performed using principal component analysis or autoencoder networks to reduce the dimensionality of high-dimensional local features and extract the most representative global features. Within a preset time period, the global difference compensation features are broadcast and mapped to the first agent to the Nth agent. The specific function of this mechanism is to significantly reduce the computational complexity of global differences by combining sharded parallelism with distributed dimensionality reduction, and to significantly reduce network bandwidth consumption during broadcast mapping, thus ensuring that cross-iterative updates can still maintain low latency and high throughput in scenarios with large data volumes and multiple agents.

[0035] Finally, this invention also provides a method for developing an intelligent agent for enterprise data integration. The specific steps of this method correspond one-to-one with the execution logic of each module in the above system embodiments. By acquiring multi-format enterprise data, preprocessing and constructing intelligent agents, batch processing to generate translated backup data groups, extracting time-series snapshots to compare differences and perform periodic cross-iterative mapping, and independently responding to new data writing to update the local tool call structure, all the technical effects of the above system are fully realized, ensuring high availability and dynamic adaptive updates of data integration under multi-agent collaboration.

[0036] Through the specific implementation of the above system and method, the following significant beneficial effects have been achieved compared with the existing technology: By constructing a first and a second intelligent agent, and having the first agent batch process enterprise data to obtain a first data set while simultaneously outputting data to the second agent to generate a second data set as a translation backup, structured encapsulation and heterogeneous backup of multi-format enterprise data at the agent level are achieved. Specifically, the second agent uses a different data parsing engine or underlying storage structure than the first agent during batch processing, achieving true heterogeneous backup at both the physical and logical levels. This mechanism not only enables enterprise data to directly adapt to the calling protocol of large language models, lowering the deployment and integration threshold of intelligent agents, but also completely avoids business interruptions caused by single-point data failures or single-format parsing errors, significantly improving the high availability and fault tolerance of system data integration.

[0037] By employing a time-series snapshot mechanism based on metadata pointer offset, index tree copying, and timestamp alignment, the traditional time-consuming physical copying of full data has been completely transformed. This mechanism can complete the construction of the first and second snapshots within milliseconds, significantly reducing system I / O overhead. Simultaneously, by freezing data writing after the timestamp through a global clock synchronization protocol, it ensures absolute consistency of the extracted two snapshots in the time dimension, effectively avoiding spurious data differences caused by data write time differences, and providing a high-purity, high-reliability prior benchmark for subsequent difference comparisons.

[0038] The data update module first configures the process by extracting two snapshots and comparing data differences. These differences are then semantically vectorized to accurately extract field offsets and relationship gaps. This allows for the construction of difference compensation features, including compensation weights and update paths, which are mapped to the agent body according to a preset time period to update configuration items. This mechanism accurately captures subtle data drift caused by changes in data volume during batch processing. Through periodic cross-iterative updates, it automatically compensates for and corrects the agent's context management rules and workflow logic (such as dynamically adjusting batch processing node weights and verification thresholds), ensuring data consistency in a multi-node collaborative state and avoiding the computational resource consumption and response latency caused by traditional full-scale reconstruction.

[0039] A fast mapping is achieved by directly binding feature vectors or structured parameters from the source dataset to the memory address or index path of the corresponding configuration item within the target agent's coded file. In multi-agent collaborative scenarios, a global configuration mapping table and a lock-free concurrent queue are combined to achieve parallel distribution of difference-compensated features and millisecond-level hot configuration updates. The target agent can directly execute new logical instructions in the next runtime cycle without re-parsed the massive data stream, ensuring efficient flow of cross-iterative updates among multiple agents and completely eliminating the network latency and parsing overhead caused by traditional configuration distribution.

[0040] Through the second configuration of the data update module, when new enterprise data is written to the system within a preset time period, an incremental write event is independently triggered, and the tool call structure of the first agent is locally updated based on the incremental data tags. This mechanism achieves real-time and accurate response to new data injection and plug-and-play local incremental updates. Moreover, this real-time update process is completely independent of the periodic cross-iteration process of the first configuration at the logical and execution levels, effectively avoiding mutual blocking and interference between background iteration tasks and front-end real-time write tasks, and ensuring the agent's high concurrency processing capability, real-time performance, and version management stability in dynamic data environments.

[0041] By introducing a multi-agent cross-data backup mode and a large-scale data sharding and dimensionality reduction mechanism, the limitations of traditional linear backup are broken. In the cross-mode, by constructing a data flow topology graph and mapping cross-difference compensation features along the reverse path, responsibility tracing and accurate compensation between multiple nodes are achieved, greatly improving the robustness of multi-node cross-iterative updates in complex business networks. In large-scale data scenarios, by sharding data groups, extracting local snapshots in parallel, and performing dimensionality reduction and fusion through distributed computing to obtain global difference compensation features, the computational complexity of global differences is greatly reduced, ensuring that the system can still maintain low latency and high throughput iterative update capabilities in scenarios with massive data and multi-agent concurrency.

[0042] The foregoing description and accompanying drawings fully illustrate embodiments of this disclosure to enable those skilled in the art to practice them. Other embodiments may include structural, logical, electrical, procedural, and other changes. The embodiments represent variations only. Individual components and functions are optional unless explicitly required, and the order of operations may vary. Parts and features of some embodiments may be included in or replace parts and features of other embodiments. Moreover, the terminology used in this application is for describing embodiments only and is not intended to limit the claims. As used in the description of embodiments and claims, the singular forms “a,” “an,” and “the” are intended to equally include the plural forms unless the context clearly indicates otherwise. Similarly, the term “and / or” as used in this application means including one or more of the associated listed combinations. Additionally, when used in this application, the term "comprise" and its variations "comprises" and / or "comprising" refer to the presence of stated features, integrals, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components, and / or groups thereof. Without further limitations, an element defined by the phrase "comprises a..." does not exclude the presence of other identical elements in the process, method, or apparatus that includes said element. In this document, each embodiment may focus on the differences from other embodiments, and similar or identical parts between embodiments can be referred to mutually. For methods, products, etc., disclosed in the embodiments, if they correspond to the method section disclosed in the embodiments, the relevant parts can be referred to the description of the method section.

[0043] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented using electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods for each specific application to achieve the described functions, but such implementation should not be considered beyond the scope of the embodiments of this disclosure. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the described devices, apparatuses, and units can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0044] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, function, and operation of implementations of apparatus, methods, and computer program products according to embodiments of the present disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions indicated in the blocks may occur in a different order than indicated in the drawings. For example, two consecutive blocks may actually be executed substantially in parallel, or they may sometimes be executed in reverse order, depending on the functions involved. In the descriptions corresponding to the flowcharts and block diagrams in the accompanying drawings, the operations or steps corresponding to different blocks may also occur in a different order than disclosed in the description; sometimes there is no specific order between different operations or steps. For example, two consecutive operations or steps may actually be executed substantially in parallel, or they may sometimes be executed in reverse order, depending on the functions involved. Each block in a block diagram and / or flowchart, and combinations of blocks in a block diagram and / or flowchart, can be implemented using a dedicated hardware-based device that performs the specified function or action, or using a combination of dedicated hardware and computer instructions.

Claims

1. A development system for an enterprise data integration intelligent agent, characterized in that, include: The data acquisition module is configured to acquire enterprise data in multiple formats; The data processing module is configured to preprocess the enterprise data and construct at least a first intelligent agent and a second intelligent agent. Each intelligent agent includes an encapsulated coded file, and the configuration items encapsulated in the coded file include an intelligent agent identifier, a tool invocation structure, context management rules, and workflow logic. The first intelligent agent is configured to batch process the enterprise data to obtain first data and second data, encapsulate the first data to obtain a first data group, and output the second data to the second intelligent agent. The second agent is configured to batch process the second data to obtain a second data group, and the second data group is a translated backup of the first data group; The data update module includes a first configuration and a second configuration. The first configuration is configured to extract a first snapshot and a second snapshot corresponding to the first data group and the second data group, respectively, compare the data differences between the first snapshot and the second snapshot, convert the data differences into structured difference compensation features, and map the difference compensation features to the first intelligent agent and the second intelligent agent respectively according to a preset time period, and update the configuration items of the coded file. The second configuration is configured such that when new enterprise data is written to the system within the preset time period, a response is executed to write the new enterprise data to the first data group and update the configuration items of the coded file.

2. The system according to claim 1, characterized in that, When the data update module executes the first configuration, it also performs the following steps: When the preset time period arrives, the data difference is semantically vectorized to extract the field offset and relationship discontinuity caused by the change in data volume, and the difference compensation feature containing compensation weight and update path is constructed. The difference compensation features are respectively input into the context management rules of the first agent and the second agent. The first agent adjusts the batch processing node weight in its workflow logic based on the difference compensation features, and the second agent adjusts the verification threshold of its translation backup based on the difference compensation features, so as to complete the cross-iterative update between the first agent and the second agent within the preset time period.

3. The system according to claim 2, characterized in that, When the data update module executes the second configuration, it also performs the following steps: Independent of the first configuration, when new enterprise data is detected being written to the system, an incremental write event is triggered; The new enterprise data is appended to the first data group, and corresponding incremental data tags are generated synchronously. Based on the incremental data tags, the tool call structure in the coded file of the first agent is partially updated so that the first agent can batch process the new enterprise data based on the updated tool call structure before the next preset time period arrives.

4. The system according to claim 1, characterized in that, The mapping is specifically as follows: The feature vectors or structured parameters in the source dataset are bound to the memory address or index path of the corresponding configuration item in the encodeable file of the target agent through a preset transformation function or routing protocol to obtain logical instructions.

5. The system according to claim 1, characterized in that, The data processing module constructs a first agent to an Nth agent, where N is an integer greater than 2, and the data configuration mode between the agents includes a first mode and a second mode; in the first mode, each agent performs sequential data backup, that is, the i-th agent outputs data to the (i+1)-th agent for translation and backup, where i is an integer greater than or equal to 1 and less than N; In the second mode, each of the intelligent agents performs cross-data backup, that is, the data of any intelligent agent is randomly output to another intelligent agent to achieve data backup.

6. The system according to claim 5, characterized in that, In the second mode, the data update module is specifically configured as follows: Construct a data flow topology graph containing all the agents, and extract data snapshots of any two agents that are backups of each other based on the randomly output path; Calculate the asymmetric data difference between any two data snapshots of the agents, and transform the asymmetric data difference into a cross-difference compensation feature with a flow direction identifier; According to the preset time period, the cross-difference compensation feature is mapped to the corresponding intelligent body along the reverse path of the data flow topology graph, and the configuration items of the corresponding coded file are updated to realize multi-node cross-iterative update.

7. The system according to claim 6, characterized in that, The data update module is specifically configured as follows: The data sets of the first to Nth agents are divided into multiple data subsets, and an independent computing thread is allocated to each data subset. Within each of the aforementioned computation threads, local snapshots of the corresponding data subsets are extracted in parallel, local data differences are calculated, and local difference compensation features are generated. The local difference compensation features are reduced in dimensionality and fused through distributed computing to obtain global difference compensation features. Within the preset time period, the global difference compensation features are broadcast and mapped to the first to the Nth intelligent agents, and the configuration items of the coded file are updated.

8. A method for developing an enterprise data integration intelligent agent, characterized in that, Includes the following steps: Acquire enterprise data in multiple formats; The enterprise data is preprocessed, and at least a first intelligent agent and a second intelligent agent are constructed. Each intelligent agent includes an encapsulated coded file. The configuration items encapsulated in the coded file include an intelligent agent identifier, a tool invocation structure, context management rules, and workflow logic. The first intelligent agent batch processes the enterprise data to obtain first data and second data, encapsulates the first data to obtain a first data group, and outputs the second data to the second intelligent agent. The second data group is obtained by batch processing the second data through the second intelligent agent, and the second data group is a translated backup of the first data group; First snapshot and second snapshot corresponding to the first data group and the second data group are extracted respectively. The data differences between the first snapshot and the second snapshot are compared. The data differences are converted into structured difference compensation features. According to a preset time period, the difference compensation features are mapped to the first intelligent agent and the second intelligent agent respectively, and the configuration items of the coded file are updated. Within the preset time period, when new enterprise data is written to the system, a response is executed to write the new enterprise data to the first data group and update the configuration items of the coded file.

Images