Method and system for knowledge-augmented agent data source integration for low-code platforms

Abstract

This invention discloses a knowledge-enhanced intelligent agent data source integration method and system for a low-code platform, comprising: responding to data operation requests in low-code applications, invoking a preset standardized interaction protocol and an integrated dynamic data source to obtain dynamic execution results; performing structured mapping and backfilling on the execution results to obtain business-driven information and outputting application responses; the construction process of the integrated dynamic data source: integrating unstructured knowledge assets and AI intelligent agent reasoning capabilities to construct a knowledge intelligent agent fusion service; and adjusting standard service primitives using a dynamic context-aware strategy to output enhanced reasoning instructions and generate dynamic data source interfaces. This invention, by constructing a knowledge intelligent agent fusion service and utilizing a dynamic context-aware strategy to proactively mine explicit business parameters and implicit runtime context, achieves a leap from simple data querying to intelligent intent understanding, thereby improving the intelligent integration efficiency of the low-code platform.

Description

Technical Field

[0001] This invention relates to the fields of computer software technology and artificial intelligence applications, and more specifically, to a method and system for integrating knowledge-enhanced intelligent agent data sources on a low-code platform. Background Technology

[0002] Low-code platforms have become a mainstream tool for enterprises to quickly build applications, allowing developers to easily build business systems by dragging and dropping components. However, in actual implementation, people have found that the most troublesome aspect of low-code platforms is often data integration. Traditional low-code models excel at handling well-organized structured data in databases, but when it comes to a large amount of unstructured knowledge within an enterprise, such as rules and regulations, historical cases, or technical manuals scattered in documents, the platform falls short. It usually has to rely on hardcoding to call APIs, making it difficult for applications to truly understand this business knowledge.

[0003] To address this issue, many solutions have begun to introduce AI agents, leveraging the reasoning capabilities of large models to assist low-code development. For example, existing technology CN120929089B discloses a method and system for generating business module source code based on large model business reasoning. This method constructs a weighted business association graph by semantically parsing business requirements, decomposes tasks into sub-tasks, calls multi-agent agents trained in a domain-adaptive, phased manner to collaboratively generate module code, and introduces a verification agent for quality evaluation, thereby improving the efficiency and accuracy of code generation. However, current common practices mostly rely on retrieval-enhanced generation, i.e., searching for relevant knowledge first and then letting AI answer. This sounds good, but in the dynamic environment of low-code, this static retrieval method is often insufficient. This is because it usually only focuses on the few words entered by the user, ignoring the important implicit context of system operation, such as which department the current operator is from, the current stage of the process, and what data was entered in the previous component. Lacking this background information, the suggestions given by AI are often vague or even misleading, failing to directly drive business execution.

[0004] A deeper problem lies in the fact that different business scenarios have drastically different requirements for the granularity of knowledge. For example, if you're filling out a form for a reimbursement amount, you need numerical rules accurate to the decimal point; but if you're configuring an approval process, you need a macro-level logical description. Most existing technical solutions use a one-size-fits-all retrieval strategy, either searching too finely, letting the AI ​​get overwhelmed by noise, or searching too broadly, missing crucial details. Moreover, if the initial granularity of the search is incorrect, the system often goes down the wrong path and directly outputs incorrect results, lacking a flexible mechanism that can self-awareness and automatically adjust the search scope until a match is found.

[0005] This has led to an awkward situation for current low-code platforms during intelligent upgrades: although AI has been integrated, the inability to accurately parse the relationship between explicit fields and implicit context, coupled with a lack of adaptive granular matching capabilities, makes data source integration still rigid and inefficient. The system struggles to dynamically generate accurate inference instructions based on real-time business scenarios, preventing unstructured knowledge from being truly transformed into executable business drivers. Therefore, a new integration method is urgently needed to break through this bottleneck, enabling intelligent agents to understand scenarios, dynamically adjust knowledge granularity, and automatically correct retrieval biases. Summary of the Invention

[0006] The purpose of this invention is to overcome the shortcomings of the prior art and provide a method and system for integrating knowledge-enhanced intelligent agent data sources on a low-code platform, so as to solve the reasoning bias problem caused by the lack of implicit context and rigid retrieval granularity, and realize the accurate conversion of unstructured knowledge into executable business instructions.

[0007] The objective of this invention is achieved through the following technical solution: A method for integrating data sources for knowledge-enhanced intelligent agents on a low-code platform includes: In response to data manipulation requests from low-code applications, it invokes a pre-defined standardized interaction protocol and an integrated dynamic data source to obtain dynamic execution results; The dynamic execution results are structured and backfilled to obtain business-driven information and output application response; The construction process of the integrated dynamic data source is as follows: Integrate unstructured knowledge assets with AI agent reasoning capabilities to build a knowledge agent fusion service; Standard service primitives are obtained by encapsulating and parsing the protocol gateway module. The standard service primitives are adjusted using a dynamic context-aware strategy to output enhanced inference instructions and generate dynamic data source interfaces; The dynamic context-aware strategy includes: parsing business fields in data operation requests into first explicit parameters; initiating secondary queries based on runtime metadata to obtain a second implicit context; and using a scenario matching algorithm to match the optimal knowledge granularity. If the current association granularity does not match the optimal knowledge granularity, the query range is adjusted and the second implicit context is retrieved again until a match is successfully obtained, at which point an enhanced reasoning instruction is generated. The scenario matching algorithm adjusts the granularity of knowledge retrieval by configuring low-code component types to adapt to business entity values ​​or process descriptions.

[0008] As a preferred approach, the standard operation primitives defined by the standardized interaction protocol include at least the following: query operation, execute operation, subscribe operation, and describe operation; The query operation is used to initiate a semantic retrieval to the knowledge base, and the request parameters include natural language questions and / or structured filtering conditions; The execute operation is used to trigger a specified AI agent to perform reasoning or decision-making tasks. The request parameters include the agent identifier, task type, and input context. The subscribe operation is used to subscribe to knowledge base update events or asynchronous result pushes from the agent; The describe operation is used to dynamically obtain the capability metadata of the integrated dynamic data source, including available knowledge base categories, agent list and their input / output parameter patterns.

[0009] As a preferred approach, during the execution of the execute operation, an adaptive retrieval strategy based on information entropy is used to dynamically determine the number of knowledge retrievals. The specific calculation formula is as follows: ; in, This represents the final number of knowledge retrievals. This represents the preset base search size, indicating the default recall at standard resolution. The Shannon information entropy, representing the data operation request text, is used to quantify the uncertainty or ambiguity of the query statement. The calculation formula is as follows: in For word frequency probability; This represents the preset entropy threshold, which signifies the dividing point between "clear query" and "fuzzy query" as determined by the system. This represents the entropy normalization constant; This represents the natural constant, serving as the base for exponential growth, ensuring that the number of searches expands rapidly and non-linearly with increasing uncertainty; This indicates a rounding function that ensures the number of retrieved segments is a positive integer.

[0010] As a preferred approach, the structured mapping and backfilling specifically include: The dynamic execution result is broken down into multiple sub-result units, which include form fill values, process branch conditions, or report data items. The multiple sub-result units are logically integrated and type constraint verified to output the business-driven information. The type constraint validation includes data type matching validation, value range validity validation, and low-code component compatibility validation.

[0011] As a preferred approach, a preset service is also included, the preset service logic comprising: When a data operation request originates from a form input component, real-time risk warning logic is triggered, delaying the execution operation during user input and displaying suggested values. When a data operation request originates from a process gateway node, the automatic routing decision logic is triggered, which automatically assigns specific field values ​​from the dynamic execution result to process variables to determine the flow direction.

[0012] As a preferred approach, visual configuration is also included, the visual configuration process comprising: Extend the Smart Data Source Properties panel in the Low-Code Platform Designer; The smart data source property panel allows for the declarative binding of the UI component's option list or default value to the query operation. The automatic execution actions or judgment conditions of the process nodes can be bound to the execute operation through the intelligent data source attribute panel; The intelligent data source property panel automatically maps component values ​​or process variables to the first explicit parameters for the agent to perform tasks.

[0013] As a preferred approach, when generating enhanced inference instructions, a spatiotemporal decay injection model is used to calculate the injection weights of the latent context. The specific calculation formula is as follows: ; in, This represents the implicit context injection weight, with a value range of [0, 1], which determines the influence of the implicit context in the inference instructions; The cosine similarity score between the implicit context and the current business scenario is represented, with a value range of [-1, 1], and is used in the calculation after normalization. This represents the activation threshold, used to control the activation center point of the Sigmoid function; This represents the kurtosis coefficient, used to control the sensitivity of similarity changes to weights; It represents the time difference between the generation of implicit context data, in seconds (s), that is, the difference between the current time and the time when the data was generated; This represents the preset maximum effective time window, in seconds (s). When the units are consistent, When this term is 0, λ represents the time decay rate exponent, which is used to adjust the decay rate of the time factor on the weight. Represents the natural constant.

[0014] A low-code platform knowledge-enhanced intelligent agent data source integration system, comprising: An integrated dynamic data source server is used to encapsulate unstructured knowledge assets and AI agents within an enterprise, and provides a dynamic data source interface with a standardized data interaction protocol definition. The low-code platform adapter, deployed on the low-code platform side, is used to translate data operation requests within the platform into request messages that conform to the standardized data interaction protocol, and deserialize the returned dynamic execution results into the platform data model; The visual configuration extension module, integrated into the low-code platform designer, provides a visual binding and configuration interface for the integrated dynamic data source, supporting developers to bind knowledge retrieval or intelligent agent reasoning capabilities to application components. The dynamic context awareness unit, embedded in the integrated dynamic data source server, is used to parse the first explicit parameters and obtain the second implicit context. It uses an information entropy-based adaptive retrieval strategy and a spatiotemporal decay injection model to generate enhanced inference instructions to guide the AI ​​agent to perform collaborative inference. The modules work together to enable native invocation of the knowledge intelligence fusion service in low-code applications and automatic backfilling of business-driven information.

[0015] As a preferred embodiment, the integrated dynamic data source server also includes: The protocol gateway module is used to parse and route requests from the low-code platform adapter, and distribute them to the dynamic knowledge base management module or the agent factory and inference engine module according to the operation type. The dynamic knowledge base management module is responsible for the vectorized storage, index update, and context-based semantic retrieval of unstructured knowledge assets. It also calculates the Shannon information entropy of the query statement in real time when a request is received to perform adaptive retrieval. The intelligent agent factory and inference engine module is responsible for task chain orchestration, dynamic context awareness, and collaborative reasoning execution. It can dynamically adjust the inference strategy based on the calculated implicit context injection weights and prioritize injecting high-weight contexts into the prompt word project.

[0016] As a preferred embodiment, the visualization configuration extension module is specifically configured as follows: Extend the "Smart Data Source" property panel on form fields, process nodes, or report components in the low-code platform designer; Developers can bind the data source of UI components to the query operation or bind the execution logic of process nodes to the execute operation by dragging or selecting. It supports configuring parameter mapping rules to automatically convert variables in low-code applications into the first explicit parameters required by the agent, and provides a real-time preview in the panel of the estimated Shannon information entropy value and expected retrieval scale based on the current input.

[0017] The present invention has at least the following beneficial effects: This invention, by constructing a knowledge intelligence fusion service, deeply integrates unstructured knowledge with AI reasoning capabilities. Utilizing a dynamic context-aware strategy, it proactively mines "explicit business parameters" and "implicit runtime context," achieving a leap from simple data querying to intelligent intent understanding. The system can automatically adjust the retrieval granularity based on the type of low-code components. When a granularity mismatch is detected, it ensures accurate adaptation of output instructions to the business scenario through a dynamic closed loop of adjusting the scope, retrieving the context, and regenerating instructions. This method of encapsulating heterogeneous data sources into standard service primitives and dynamically generating interfaces in real time not only shields the underlying complexity but also achieves high-efficiency and high-precision business-driven information backfilling at extremely low development costs, significantly improving the intelligent integration efficiency of low-code platforms in complex scenarios. Attached Figure Description

[0018] To reveal the technical details of the embodiments of the present invention, the accompanying drawings involved in the embodiments will be briefly described below. It should be emphasized that these drawings only present several embodiments of the present invention and should not be considered as defining the scope of the invention. For those skilled in the art, other related drawings can still be derived based on these drawings without inventive effort.

[0019] Figure 1 A schematic diagram of a method for integrating data sources into a knowledge-enhanced intelligent agent on a low-code platform; Figure 2 This is a schematic diagram of a knowledge-enhanced intelligent agent data source integration system for a low-code platform. Detailed Implementation

[0020] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings, but the scope of protection of the present invention is not limited to the following description.

[0021] The embodiments of this disclosure are described in detail below with reference to the accompanying drawings. It should be understood that the scope of protection of this disclosure is not limited to the specific embodiments shown in the figures, but should be understood to cover various variations, equivalents, and alternatives based on these embodiments. In the description of the drawings, the same reference numerals will be used to refer to the same or similar components for ease of understanding.

[0022] like Figure 1 As shown, a method for integrating data sources for a knowledge-enhanced intelligent agent on a low-code platform includes: In response to data manipulation requests from low-code applications, it invokes a pre-defined standardized interaction protocol and an integrated dynamic data source to obtain dynamic execution results; The dynamic execution results are structured and backfilled to obtain business-driven information and output application response; The construction process of the integrated dynamic data source is as follows: Integrate unstructured knowledge assets with AI agent reasoning capabilities to build a knowledge agent fusion service; Standard service primitives are obtained by encapsulating and parsing the protocol gateway module. The standard service primitives are adjusted using a dynamic context-aware strategy to output enhanced inference instructions and generate dynamic data source interfaces; The dynamic context-aware strategy includes: parsing business fields in data operation requests into first explicit parameters; initiating secondary queries based on runtime metadata to obtain a second implicit context; and using a scenario matching algorithm to match the optimal knowledge granularity. If the current association granularity does not match the optimal knowledge granularity, the query range is adjusted and the second implicit context is retrieved again until a match is successfully obtained, at which point an enhanced reasoning instruction is generated. The scenario matching algorithm adjusts the granularity of knowledge retrieval by configuring low-code component types to adapt to business entity values ​​or process descriptions.

[0023] Specifically, the integration method described in this embodiment is based on a clear four-layer architecture model: the top layer is the low-code application layer, responsible for carrying specific business forms, processes, and reports; the second layer is the low-code platform layer, including the platform runtime engine, low-code platform adapter, and visual configuration extension module; the third layer is the core integrated data source service layer, namely the integrated dynamic data source server, which encapsulates the protocol gateway, dynamic knowledge base management, and intelligent agent factory and inference engine; the bottom layer is the resource layer, including the enterprise's internal unstructured document library, vector database, and external AI model resources. These four layers work together to form a complete closed loop from knowledge storage and intelligent processing to front-end application invocation, providing a basic operating environment for the execution of the aforementioned dynamic context-aware strategy and standardized interaction protocol.

[0024] The significant benefits of this embodiment are that it enables "one-time access, multiple reuses" and "centralized updates, global effectiveness" of intelligent capabilities. When enterprise business rules or knowledge base content change, maintenance and updates are only required on the centralized, integrated dynamic data source server. All low-code applications accessed through this architecture immediately obtain the latest knowledge support and reasoning capabilities, without the need to modify application code individually or redeploy applications. This significantly reduces system maintenance costs and iteration cycles, and builds a sustainable and evolving intelligent development ecosystem.

[0025] In a preferred embodiment, to address the inefficiency caused by traditional methods blindly expanding or narrowing the query scope when granularity mismatches occur, this system employs a dynamic granularity correction method based on Semantic Structure Coupling (SSCD). This method not only determines whether a match exists but also quantifies the degree of mismatch, thereby accurately calculating the granularity adjustment step size for the next retrieval. Specifically, when the scene matching algorithm detects the current association granularity... With optimal knowledge granularity When there is a mismatch, the system first calculates the current search result set. Constraints on the target low-code component structure Coupling score between The calculation formula is as follows: ; in, This represents the semantic structure coupling score, with a value range of [0, 1]. This indicates the number of valid knowledge fragments in the current search results set, expressed in units of individual fragments. Indicates the first The normalized weight coefficients of each knowledge fragment in the current result set. and These are the key semantic vector and the schema definition vector (the schema definition vector is the result of converting the structural constraint information (metadata) of low-code components or databases into a high-dimensional numerical vector that can be computed by a computer). represents a linear mapping function that maps cosine similarity from [-1, 1] to [0, 1]. Indicates the length penalty coefficient, [length]. . and These represent the current average text length and the target optimal information carrying length, respectively. Represents the natural constant.

[0026] Based on the calculation Dynamically adjust the granularity scaling factor for the next round of retrieval. The formula is: ; in To adjust the sensitivity coefficient, sgn(·) is the sign function. If Low and too short ( ),but The system automatically expands the search scope when the granularity scaling factor is greater than 1, and conversely, narrows it when the granularity scaling factor is less than 1, thus streamlining the recall results to focus on core semantics. This method represents a leap from binary judgment to continuous quantitative adjustment. For example, the system directly applies the calculated granularity scaling factor to the basic recall parameter of the search engine, dynamically adjusting the scale of the next round of searches through multiplication. Specifically, when it is determined that the search scope needs to be expanded, the scaling factor is greater than 1, and the system sets the next round's search count to the product of the current count and the factor, rounded up, thereby linearly increasing the number of recalled knowledge fragments to supplement information density; conversely, when it is determined that the search scope needs to be narrowed, the scaling factor is less than 1, and the system sets the search count to the product of the current count and the factor, rounded down, thereby streamlining the recall results to focus on core semantics. This operation transforms the abstract coupling score into the specific number of database query results returned, achieving automated and continuous adjustment of the search window size.

[0027] In a preferred embodiment, considering the varying requirements for inference accuracy and response latency across different business scenarios, as well as the limitations of large model invocation costs, the agent factory and inference engine module employ a routing strategy based on dynamic game theory of confidence cost when performing the execute operation. This strategy no longer fixates on calling a single agent, but dynamically determines whether to use a single fast inference, multi-expert voting verification, or a human-machine collaborative mode based on the expected returns calculated in real time. We first construct a dynamic decision function. This is used to evaluate the overall utility value of different execution strategies. For candidate strategies... (e.g., single-model direct output, dual-model cross-validation, three-model majority voting), the utility value calculation formula is as follows: ; in, Indicates the first The overall utility score of the implementation strategy. These represent the weighting coefficients for accuracy, cost, and timeliness, respectively. This represents the expected confidence level probability, with a value range of [0,1]. This represents the confidence level gain coefficient; and These are the estimated cost and the maximum budget, respectively, and the units must be consistent (e.g., yuan or points). and These are the estimated latency and the allowable threshold, respectively, and the units must be consistent (e.g., milliseconds). Represents the natural constant.

[0028] The system performs parallel computation of each strategy. Value. If a simple query is performed and (Expected confidence probability) is high, tending to choose a single-model strategy; if complex scenarios lead to Low, automatically guided to a multi-model voting strategy; if all strategies All are below the preset threshold This triggers the human-machine collaboration mode. This strategy achieves intelligent resource scheduling through mathematical modeling, maximizing the system's operational efficiency while ensuring the accuracy of low-code application business logic.

[0029] In a preferred embodiment, the standard operation primitives defined by the standardized interaction protocol include at least the following: query operation, execute operation, subscribe operation, and describe operation; The query operation is used to initiate a semantic retrieval to the knowledge base, and the request parameters include natural language questions and / or structured filtering conditions; The execute operation is used to trigger a specified AI agent to perform reasoning or decision-making tasks. The request parameters include the agent identifier, task type, and input context. The subscribe operation is used to subscribe to knowledge base update events or asynchronous result pushes from the agent; The describe operation is used to dynamically obtain the capability metadata of the integrated dynamic data source, including available knowledge base categories, agent list and their input / output parameter patterns.

[0030] This standardized interaction protocol establishes a clear and efficient dialogue between low-code applications and intelligent data sources by defining four core operation primitives. First, the system uses the `describe` operation as the starting point for interaction, allowing the low-code platform to dynamically acquire the data source's capability metadata at design or runtime, much like consulting a real-time updated "service catalog." This clarifies which knowledge bases are currently available, what capabilities the agent possesses, and what parameters need to be passed in, laying the foundation for subsequent calls. Building on this, when a business scenario requires specific information, the application initiates a `query` operation, sending the user's natural language question or structured filtering conditions to the knowledge base. The system then performs semantic retrieval and returns matching knowledge fragments, solving the "what to search" problem. When business logic involves complex judgments or decisions, the `execute` operation is triggered, specifying a particular AI agent and passing in the task context to drive the agent to perform deep reasoning and output decision results, solving the "how to do it" problem. Finally, to handle real-time changes in business states, the `subscribe` operation provides an asynchronous listening mechanism, allowing low-code applications to subscribe to knowledge base update events or completion notifications of long-running inference tasks, ensuring the front-end interface can respond instantly to data changes or obtain final results. These four operations are interconnected, from capability discovery to information retrieval, and then to intelligent decision-making and event monitoring, together forming a complete, flexible, and standardized data interaction closed loop.

[0031] In a preferred embodiment, during the execution of the execute operation, an adaptive retrieval strategy based on information entropy is used to dynamically determine the amount of knowledge retrieved. The specific calculation formula is as follows: ; in, This indicates the final number of knowledge retrievals, expressed in units of knowledge fragments. This represents the preset base retrieval count, in units of knowledge fragments, and indicates the default recall under standard resolution. The Shannon information entropy, expressed in bits, represents the data operation request text and is used to quantify the uncertainty or ambiguity of the query statement. The calculation formula is as follows: in For word frequency probability; This represents the preset entropy threshold value, expressed in bits, and signifies the dividing point between "clear query" and "fuzzy query" as determined by the system. This represents the entropy normalization constant, which takes a value of 1 bit. It is used to eliminate the dimension of the entropy difference in the molecule and convert the exponential part into a dimensionless value. This represents the natural constant, serving as the base for exponential growth, ensuring that the number of searches expands rapidly and non-linearly with increasing uncertainty; This indicates a rounding function that ensures the number of retrieved segments is a positive integer.

[0032] When executing complex reasoning tasks, the system's built-in adaptive retrieval strategy acts as an intelligent information radar, dynamically adjusting the search range based on the ambiguity of the user's instructions, rather than mechanically returning a fixed number of results. Upon receiving a task request, the system first calculates the information entropy of the instruction, much like analyzing signal noise, to quantify the uncertainty of the query. If the user's instruction is clear and unambiguous with a single intent, the calculated entropy value is low, and the system determines that a broad search is unnecessary; recalling only a small number of high-precision core knowledge fragments is sufficient to meet the reasoning needs, thus saving computational resources. Conversely, if the user's instruction is ambiguous, contains multiple possibilities, or lacks context, causing the entropy value to far exceed the preset clarity threshold, the system immediately activates an expansion mechanism, using an exponential growth model to non-linearly and significantly increase the number of searches, ensuring that potentially relevant marginal knowledge is also included, preventing reasoning failures due to information omissions. This mechanism is essentially an "on-demand" intelligent balancing technique, allowing the search volume to automatically scale with the complexity of the problem. This avoids resource waste on simple problems while ensuring information completeness in complex and ambiguous scenarios, ultimately providing the AI ​​agent with just the right knowledge context to support high-quality decision-making.

[0033] In a preferred embodiment, after outputting an application response that conforms to preset business logic, the method further includes: Identify whether the key decision information in the application response contains specific knowledge source tags; If not, perform uncertainty estimation and knowledge base consistency checks on the key decision information, and mark the key decision information as content to be verified; The content to be verified is pushed to the manual review end or the large language model secondary verification end for review.

[0034] After the system generates an application response that conforms to business logic, to ensure the reliability and traceability of decisions, the process automatically enters a crucial "source tracing quality inspection" stage. The system first scans the key decision points in the response content, checking whether they are accompanied by clear knowledge source markers, i.e., confirming that each conclusion is verifiable. If some key decisions lack specific source citations, the system immediately initiates risk defense. On the one hand, it performs an uncertainty assessment to determine the confidence level of the information; on the other hand, it compares the information with existing facts in the knowledge base. Once confirmed as sourceless or questionable content, it is marked as pending verification. Subsequently, these marked high-risk decisions are not directly delivered to the user but are automatically routed to a review channel: for highly sensitive scenarios, the system pushes them to a human reviewer for expert verification; for routine scenarios, a large language model is invoked for secondary logical verification. This progressive processing mechanism of "source tracing first, then assessment, then review" effectively builds the last line of defense against illusions and erroneous decisions, ensuring that every business instruction output can withstand scrutiny.

[0035] In a preferred embodiment, after accessing the unstructured knowledge assets, the method further includes: Analyze query failure logs and missed high-confidence answers to identify whether there are knowledge gaps in the unstructured knowledge assets; If so, based on expert feedback or user correction records, extract the knowledge to be supplemented and automatically fill or prompt updates to fill the knowledge gaps.

[0036] In a preferred embodiment, the structured mapping and backfilling specifically include: The dynamic execution result is broken down into multiple sub-result units, which include form fill values, process branch conditions, or report data items. The multiple sub-result units are logically integrated and type constraint verified to output the business-driven information. The type constraint validation includes data type matching validation, value range validity validation, and low-code component compatibility validation.

[0037] The structured mapping and backfilling mechanism acts as a "precise translator" connecting the intelligent inference results and the low-code business interface, transforming the unstructured or semi-structured dynamic execution results generated by AI into standardized instructions that the low-code platform can directly recognize and execute. First, the system breaks down complex execution results into fine-grained sub-result units, each precisely corresponding to a specific business action, such as the specific values ​​to be entered into a form, the judgment conditions that determine the flow of the process, or the data items to be displayed in a report. Next, the system doesn't simply piece these fragments together; instead, it rigorously integrates them logically and verifies type constraints. This process is like sifting through a sieve, checking whether the data format matches (e.g., text to text, number to number), whether the values ​​fall within a legal range (e.g., age cannot be negative), and whether the output content is compatible with the interface specifications of the target low-code component. Only sub-result units that pass these layers of verification are finally assembled into standard business-driven information, ensuring that the backfilling operation is not only logically sound but also technically safe and feasible, thus preventing system crashes or process interruptions caused by incorrect data formats or type mismatches.

[0038] In a preferred embodiment, the preset business logic includes: When a data operation request originates from a form input component, real-time risk warning logic is triggered, delaying the execution operation during user input and displaying suggested values. When a data operation request originates from a process gateway node, the automatic routing decision logic is triggered, which automatically assigns specific field values ​​from the dynamic execution result to process variables to determine the flow direction.

[0039] In a preferred embodiment, the visualization binding and parameter mapping of application interface components or process nodes with the integrated dynamic data source specifically includes the following scenario-based configurations: During the form design phase, a real-time trigger mechanism is configured for the input component, setting the `execute` operation to be called after a debouncing delay occurs during user input, enabling risk warnings or real-time display of suggested values ​​while inputting, thus improving user experience; During the process design phase, an automatic trigger mechanism is configured for the approval gateway node, automatically calling the `execute` operation when the process instance reaches the node, and automatically assigning specific field values ​​(such as "risk level" and "compliance status") from the structured conclusions output by the intelligent agent to process variables, using this as a decision-making basis to directly determine the routing branch direction of the process, achieving intelligent flow without manual intervention.

[0040] In a preferred embodiment, the visual configuration process includes: Extend the Smart Data Source Properties panel in the Low-Code Platform Designer; The smart data source property panel allows for the declarative binding of the UI component's option list or default value to the query operation. The automatic execution actions or judgment conditions of the process nodes can be bound to the execute operation through the intelligent data source attribute panel; The intelligent data source property panel automatically maps component values ​​or process variables to the first explicit parameters for the agent to perform tasks.

[0041] The core of the visual configuration process lies in transforming complex low-level code calls into intuitive attribute binding operations within a low-code platform, allowing developers to drive intelligent data sources without writing any scripts. First, the system extends a dedicated intelligent data source attribute panel within the low-code designer, essentially installing an intelligent interface for connecting to AI capabilities into ordinary components. Building upon this, developers can declaratively bind the option list or default values ​​of UI components (such as dropdown menus) to the query operation in this panel. This means that once a component is loaded, it automatically initiates a semantic search to the knowledge base and dynamically populates content, achieving intelligent data display. Furthermore, for business process control, developers only need to bind the automatic execution actions or branch judgment conditions of process nodes to the execute operation in the panel. This allows the process engine to automatically trigger the AI ​​agent to perform reasoning and decision-making based on the business state, replacing traditional hard-coded logical judgments. Finally, to ensure seamless data flow, the panel also supports automatically mapping real-time values ​​of front-end components or variables in the process to the first explicit parameters required by the AI ​​agent when executing tasks, ensuring that user input or contextual information is accurately transmitted to the AI ​​model. This series of operations is interconnected, from data display to logical decision-making to parameter transmission, all completed through visual configuration, which greatly lowers the barrier to integrating AI capabilities and allows business personnel to easily build applications with intelligent interactive capabilities.

[0042] In a preferred embodiment, the generation of the dynamic data source interface further includes: The unstructured knowledge assets are subjected to multimodal feature extraction and vectorization processing, and stored in a vector database; A knowledge version index is established. When a new unstructured knowledge asset is detected and uploaded, the knowledge version index is updated in real time to ensure that the knowledge called by the dynamic data source interface is the latest version.

[0043] In a preferred embodiment, when generating enhanced inference instructions, a spatiotemporal decay injection model is used to calculate the injection weight of the latent context, and the specific calculation formula is as follows: ; in, This represents the implicit context injection weight, with a value range of [0, 1], which determines the influence of the implicit context in the inference instructions; The cosine similarity score between the implicit context and the current business scenario is represented, with a value range of [-1, 1], and is used in the calculation after normalization. This represents the activation threshold, used to control the activation center point of the Sigmoid function; This represents the kurtosis coefficient, used to control the sensitivity of similarity changes to weights; It represents the time difference between the generation of implicit context data, in seconds (s), that is, the difference between the current time and the time when the data was generated; This represents the preset maximum effective time window, in seconds (s). When the units are consistent, When this term is 0, λ represents the time decay rate exponent, which is used to adjust the decay rate of the time factor on the weight. Represents the natural constant.

[0044] When generating enhanced inference instructions, the system introduces a spatiotemporal decay injection model to intelligently filter and weight implicit context. Its core logic is to simultaneously consider the relevance and freshness of information, ensuring that the AI ​​only references historical memories that are both relevant and timely. First, the system calculates the semantic similarity between the implicit context and the current business scenario, using a smooth activation mechanism to determine whether information is worth paying attention to: when the similarity is below a set threshold, the weight is strongly suppressed and almost negligible; however, once the similarity crosses the threshold, the weight rapidly increases, ensuring that highly relevant background information is prioritized. Next, the system adds a time-dimensional filter on top of the similarity, dynamically decaying the impact based on the time difference between data generation. This means that even highly relevant information, if generated too long ago and exceeding the preset effective window, will experience a non-linear and rapid decline in influence over time, until it becomes completely ineffective. Ultimately, the combined weight obtained by multiplying these two dimensions determines the influence of the implicit context in the inference instruction. This mechanism effectively prevents the model from being interfered with by outdated or irrelevant old data, ensuring that the inference process always makes decisions based on the latest and most relevant business context.

[0045] See Figure 2 This provides a low-code platform-based knowledge-enhanced intelligent agent data source integration system, including: An integrated dynamic data source server is used to encapsulate unstructured knowledge assets and AI agents within an enterprise, and provides a dynamic data source interface with a standardized data interaction protocol definition. The low-code platform adapter, deployed on the low-code platform side, is used to translate data operation requests within the platform into request messages that conform to the standardized data interaction protocol, and deserialize the returned dynamic execution results into the platform data model; The visual configuration extension module, integrated into the low-code platform designer, provides a visual binding and configuration interface for the integrated dynamic data source, supporting developers to bind knowledge retrieval or intelligent agent reasoning capabilities to application components. The dynamic context awareness unit, embedded in the integrated dynamic data source server, is used to parse the first explicit parameters and obtain the second implicit context. It uses an information entropy-based adaptive retrieval strategy and a spatiotemporal decay injection model to generate enhanced inference instructions to guide the AI ​​agent to perform collaborative inference. The modules work together to enable native invocation of the knowledge intelligence fusion service in low-code applications and automatic backfilling of business-driven information.

[0046] The system constructs an intelligent bridge connecting low-code applications and deep enterprise knowledge assets. Through the close collaboration of a four-layer architecture, it transforms complex AI inference capabilities into simple, visual configuration operations. First, the integrated dynamic data source server in the backend acts as a unified brain, standardizing and encapsulating the enterprise's scattered unstructured documents and AI agent capabilities, providing a unified interaction interface and shielding the complexity of the underlying technologies. When a low-code application initiates a data request, the low-code platform adapter acts as a translator, automatically converting the platform's standard operation instructions into protocol messages that the server can understand. Upon receiving the dynamic execution results returned by the AI, it deserializes them into a data model that the platform can directly recognize, achieving seamless two-way communication.

[0047] During the development and configuration phase, the visual configuration extension module empowers developers with a "what you see is what you get" capability. It simplifies knowledge retrieval or intelligent agent reasoning functions, which originally required writing code, into attribute binding operations within the designer, allowing business users to easily attach AI capabilities to forms, processes, or report components. In actual operation, once a call is triggered, the dynamic context-aware unit immediately launches a high-precision inference engine: it not only parses the explicit parameters input by the user but also automatically mines implicit context such as historical behavior, uses adaptive retrieval strategies to filter the most relevant knowledge fragments, and combines a spatiotemporal decay model to eliminate outdated information, ultimately generating an enhanced inference instruction rich in precise background information to guide the AI ​​in collaborative thinking. This entire process, from standardized encapsulation on the backend to protocol translation and visual orchestration in the middle, and then to intelligent context enhancement on the frontend, is interconnected, ultimately achieving native-level invocation of knowledge agent services in low-code applications and automatically backfilling the business decisions derived from the inference into the application interface, completing a qualitative leap from data querying to intelligent decision-making.

[0048] In a preferred embodiment, the integrated dynamic data source server further includes: The protocol gateway module is used to parse and route requests from the low-code platform adapter, and distribute them to the dynamic knowledge base management module or the agent factory and inference engine module according to the operation type. The dynamic knowledge base management module is responsible for the vectorized storage, index update, and context-based semantic retrieval of unstructured knowledge assets. It also calculates the Shannon information entropy of the query statement in real time when a request is received to perform adaptive retrieval. The intelligent agent factory and inference engine module is responsible for task chain orchestration, dynamic context awareness, and collaborative reasoning execution. It can dynamically adjust the inference strategy based on the calculated implicit context injection weights and prioritize injecting high-weight contexts into the prompt word project.

[0049] In a preferred embodiment, the visualization configuration extension module is specifically configured as follows: Extend the "Smart Data Source" property panel on form fields, process nodes, or report components in the low-code platform designer; Developers can bind the data source of UI components to the query operation or bind the execution logic of process nodes to the execute operation by dragging or selecting. It supports configuring parameter mapping rules to automatically convert variables in low-code applications into the first explicit parameters required by the agent, and provides a real-time preview in the panel of the estimated Shannon information entropy value and expected retrieval scale based on the current input.

[0050] In a preferred embodiment, the low-code platform adapter further includes: The request translation submodule is used to receive data operation requests issued by the low-code platform runtime engine, convert them into standard request messages according to the target data source identifier, and attach the necessary runtime metadata for calculating the second implicit context and time difference; The response deserialization submodule is used to receive the response returned by the integrated dynamic data source server, parse the structured data in it, and populate it into the data model or process variables of the low-code platform to drive the subsequent preset business logic.

[0051] In a preferred embodiment, the system further includes a knowledge maintenance and feedback module, used for: Monitor query failure logs and missed high-confidence answers to automatically identify knowledge gaps; It provides an expert feedback interface to receive manually supplemented knowledge content or correction instructions, and incrementally updates the unstructured knowledge assets. At the same time, it adaptively adjusts the entropy benchmark threshold and time decay rate index based on the feedback results to achieve continuous evolution and parameter self-optimization of the knowledge intelligent agent fusion service.

[0052] Specifically, the knowledge operation and feedback module constructs a continuously evolving closed loop: it monitors query failure logs and instances of missing high-confidence answers in real time, automatically identifying knowledge gaps in unstructured knowledge assets; through the provided expert feedback interface, it receives manually supplemented knowledge content or correction instructions and incrementally updates the unstructured knowledge assets; more importantly, based on long-term feedback results, the module can adaptively adjust the entropy baseline threshold in the information entropy-based adaptive retrieval strategy and the time decay rate index in the spatiotemporal decay injection model to ensure that retrieval accuracy and context injection weights dynamically evolve with changes in business scenarios.

[0053] In summary, this invention proposes a method and system for integrating knowledge-enhanced intelligent agent data sources on a low-code platform, establishing a complete technical path for transforming enterprise unstructured knowledge assets into standardized dynamic data sources in real time. This method overcomes the limitations of traditional static interfaces by constructing an integrated dynamic data source server. It utilizes a protocol gateway to encapsulate heterogeneous knowledge retrieval and AI inference capabilities into standard service primitives such as query and execute, achieving the atomic transformation of knowledge resources into programmable data interfaces. During the integration process, the system not only achieves seamless translation and bidirectional mapping between internal requests and external standard protocols through a low-code platform adapter, but also crucially introduces a dynamic context-aware method. This method adaptively adjusts the retrieval granularity based on information entropy and accurately weights implicit context using a spatiotemporal decay model, thereby injecting scenario-based intelligent logic during the data source generation stage, ensuring the business relevance and timeliness of the output data. This integration model fundamentally changes the way low-code applications acquire knowledge, enabling them to directly call dynamic data sources with deep inference capabilities through visual configuration without writing complex code, and automatically backfill intelligent decision results into business processes. Ultimately, this invention successfully addresses the pain point of unstructured knowledge being difficult to integrate natively into low-code platforms, and constructs a new integrated ecosystem where knowledge is a service and reasoning is data.

[0054] Although the present invention has been described in detail above with reference to preferred embodiments, those skilled in the art, after understanding the basic inventive concept of the present invention, will obviously be able to make various changes and modifications to it. Therefore, the appended claims are intended to cover these preferred embodiments and all equivalent changes falling within the scope of protection of the present invention. It should be noted that the above content is only an example of specific embodiments of the present invention and is not intended to limit the scope of protection of the present invention; any modifications, equivalent substitutions or improvements made under the guidance of the spirit and principles of the present invention should be included in the scope of protection of the present invention.

Claims

1. A method for integrating data sources of knowledge-enhanced intelligent agents on a low-code platform, characterized in that, include: In response to data manipulation requests from low-code applications, it invokes a pre-defined standardized interaction protocol and an integrated dynamic data source to obtain dynamic execution results; The dynamic execution results are structured and backfilled to obtain business-driven information and output application response; The construction process of the integrated dynamic data source is as follows: Integrate unstructured knowledge assets with AI agent reasoning capabilities to build a knowledge agent fusion service; Standard service primitives are obtained by encapsulating and parsing the protocol gateway module. The standard service primitives are adjusted using a dynamic context-aware strategy to output enhanced inference instructions and generate dynamic data source interfaces; The dynamic context-aware strategy includes: parsing business fields in data operation requests into first explicit parameters; initiating secondary queries based on runtime metadata to obtain a second implicit context; and using a scenario matching algorithm to match the optimal knowledge granularity. If the current association granularity does not match the optimal knowledge granularity, the query range is adjusted and the second implicit context is retrieved again until a match is successfully obtained, at which point an enhanced reasoning instruction is generated. The scenario matching algorithm adjusts the granularity of knowledge retrieval by configuring low-code component types to adapt to business entity values ​​or process descriptions.

2. The knowledge-enhanced intelligent agent data source integration method for low-code platforms according to claim 1, characterized in that, The standard operation primitives defined by the standardized interaction protocol include at least the following: query operation, execute operation, subscribe operation, and describe operation; The query operation is used to initiate a semantic retrieval to the knowledge base, and the request parameters include natural language questions and / or structured filtering conditions; The execute operation is used to trigger a specified AI agent to perform reasoning or decision-making tasks. The request parameters include the agent identifier, task type, and input context. The subscribe operation is used to subscribe to knowledge base update events or asynchronous result pushes from the agent; The describe operation is used to dynamically obtain the capability metadata of the integrated dynamic data source, including available knowledge base categories, agent list and their input / output parameter patterns.

3. The knowledge-enhanced intelligent agent data source integration method for low-code platforms according to claim 2, characterized in that, During the execution of the execute operation, an adaptive retrieval strategy based on information entropy is used to dynamically determine the number of knowledge retrievals. The specific calculation formula is as follows: ； in, This represents the final number of knowledge retrievals. This represents the preset base search size, indicating the default recall at standard resolution. The Shannon information entropy, representing the data operation request text, is used to quantify the uncertainty or ambiguity of the query statement. The calculation formula is as follows: in For word frequency probability; This represents the preset entropy threshold, which indicates the dividing point between "clear query" and "fuzzy query" as determined by the system. This represents the entropy normalization constant; This represents a natural constant, ensuring that the number of searches expands rapidly and non-linearly with increasing uncertainty; This indicates a rounding function that ensures the number of retrieved segments is a positive integer.

4. The knowledge-enhanced intelligent agent data source integration method for low-code platforms according to claim 1, characterized in that, The structured mapping and backfilling specifically include: The dynamic execution result is broken down into multiple sub-result units, which include form fill values, process branch conditions, or report data items. The multiple sub-result units are logically integrated and type constraint verified to output the business-driven information. The type constraint validation includes data type matching validation, value range validity validation, and low-code component compatibility validation.

5. The knowledge-enhanced intelligent agent data source integration method for low-code platforms according to claim 1, characterized in that, It also includes preset services, the preset service logic of which includes: When a data operation request originates from a form input component, real-time risk warning logic is triggered, delaying the execution operation during user input and displaying suggested values. When a data operation request originates from a process gateway node, the automatic routing decision logic is triggered, which automatically assigns specific field values ​​from the dynamic execution result to process variables to determine the flow direction.

6. The knowledge-enhanced intelligent agent data source integration method for low-code platforms according to claim 1, characterized in that, It also includes visual configuration, the visual configuration process of which includes: Extend the Smart Data Source Properties panel in the Low-Code Platform Designer; The smart data source property panel allows for the declarative binding of the UI component's option list or default value to the query operation. The automatic execution actions or judgment conditions of the process nodes can be bound to the execute operation through the intelligent data source attribute panel; The intelligent data source property panel automatically maps component values ​​or process variables to the first explicit parameters for the agent to perform tasks.

7. The method for integrating knowledge-enhanced intelligent agent data sources on a low-code platform according to claim 1, characterized in that, When generating enhanced inference instructions, a spatiotemporal decay injection model is used to calculate the injection weights of the latent context. The specific calculation formula is as follows: ； in, This represents the implicit context injection weight, with a value range of [0, 1], which determines the influence of the implicit context in the inference instructions; The cosine similarity score between the implicit context and the current business scenario is represented, with a value range of [-1, 1], and is used in the calculation after normalization. This represents the activation threshold, used to control the activation center point of the Sigmoid function; This represents the kurtosis coefficient, used to control the sensitivity of similarity changes to weights; This represents the time difference between the generation of implicit context data, i.e., the difference between the current time and the time when the data was generated; This indicates the preset maximum effective time window, and... When the units are consistent, When this term is 0, λ represents the time decay rate exponent, which is used to adjust the decay rate of the time factor on the weight. Represents the natural constant.

8. A knowledge-enhanced intelligent agent data source integration system for a low-code platform, characterized in that, include: An integrated dynamic data source server is used to encapsulate unstructured knowledge assets and AI agents within an enterprise, and provides a dynamic data source interface with a standardized data interaction protocol definition. The low-code platform adapter, deployed on the low-code platform side, is used to translate data operation requests within the platform into request messages that conform to the standardized data interaction protocol, and deserialize the returned dynamic execution results into the platform data model; The visual configuration extension module, integrated into the low-code platform designer, provides a visual binding and configuration interface for the integrated dynamic data source, supporting developers to bind knowledge retrieval or intelligent agent reasoning capabilities to application components. The dynamic context awareness unit, embedded in the integrated dynamic data source server, is used to parse the first explicit parameters and obtain the second implicit context. It uses the information entropy-based adaptive retrieval strategy of claim 3 and the spatiotemporal decay injection model of claim 7 to generate enhanced inference instructions to guide the AI ​​agent to perform collaborative inference. The modules work together to enable native invocation of the knowledge intelligence fusion service in low-code applications and automatic backfilling of business-driven information.

9. A knowledge-enhanced intelligent agent data source integration system for a low-code platform according to claim 8, characterized in that, The integrated dynamic data source server also includes: The protocol gateway module is used to parse and route requests from the low-code platform adapter, and distribute them to the dynamic knowledge base management module or the agent factory and inference engine module according to the operation type. The dynamic knowledge base management module is responsible for the vectorized storage, index update, and context-based semantic retrieval of unstructured knowledge assets. It also calculates the Shannon information entropy of the query statement in real time when a request is received to perform adaptive retrieval. The intelligent agent factory and inference engine module is responsible for task chain orchestration, dynamic context awareness, and collaborative reasoning execution. It can dynamically adjust the inference strategy based on the calculated implicit context injection weights and prioritize injecting high-weight contexts into the prompt word project.

10. A knowledge-enhanced intelligent agent data source integration system for a low-code platform according to claim 8 or 9, characterized in that, The specific configuration of the visual configuration extension module is as follows: Extend the "Smart Data Source" property panel on form fields, process nodes, or report components in the low-code platform designer; Developers can bind the data source of UI components to the query operation or bind the execution logic of process nodes to the execute operation by dragging or selecting. It supports configuring parameter mapping rules to automatically convert variables in low-code applications into the first explicit parameters required by the agent, and provides a real-time preview in the panel of the estimated Shannon information entropy value and expected retrieval scale based on the current input.

Images