Knowledge-guided evolutionary memory experience synthesis method and system based on hierarchical recursive divide-and-conquer

Abstract

The application discloses a knowledge-guided evolutionary memory experience synthesis method and system based on hierarchical recursive divide-and-conquer, comprising: through the cooperative work of a graph expansion agent, a graph refinement agent, a conversation landing agent and a conversation construction agent, a complete recursive cycle from time sequence event subgraph initialization to node expansion and dynamic retouching is executed, and a hierarchical interactive trajectory tree is generated; based on the hierarchical interactive trajectory tree, a question and answer pair dataset is recursively synthesized from the bottom leaf node to the top root node; and the hierarchical interactive trajectory tree and the question and answer pair dataset are verified to ensure that the output evolutionary memory experience dataset meets the requirements of high fidelity and logical rigor. In this way, the smooth transition from macro-narrative planning to micro-conversation generation is realized through the planning-execution recursive workflow, the coherence and knowledge depth of the synthesized trajectory in a long period are ensured, and the synthesis efficiency and evaluation effectiveness of the AI memory system evolutionary experience data are significantly improved.

Description

Technical Field

[0001] This invention belongs to the technical field of combining artificial intelligence and large model memory systems, specifically involving a knowledge-guided evolutionary memory experience synthesis method and system based on hierarchical recursive divide-and-conquer. Background Technology

[0002] With the evolution of large language models and AI agent technologies, long-term memory has become a key dimension for measuring whether an agent can continuously optimize service quality and achieve self-evolution in long-term interactions. To comprehensively measure the real-world performance of agents, researchers need to construct interaction trajectory datasets covering long time spans. These datasets should not be limited to anthropomorphic modeling of user profiles but should also broadly integrate complex interaction processes involving mathematical reasoning, code development, and multi-domain expertise to assess whether the agent can extract effective knowledge from long-term historical information and become more efficient as interactions deepen. Therefore, constructing interaction trajectories that can simulate real, long-term, and evolutionary characteristics is crucial for advancing the development of agents with long-term memory capabilities.

[0003] However, existing individual interaction trajectory synthesis techniques face significant technical challenges in addressing long-range evolution requirements. First, existing synthesis algorithms [1] Jiang B, Hao Z, Cho YM, et al. Know me, respond to me: Benchmarking llms for dynamic user profiling and personalized responses at scale[J]. arXiv preprint arXiv:2504.14225, 2025. [2] Wang W, Han D, Diaz DM, et al. Odysseybench: Evaluating llm agents on long-horizon complex officeapplication workflows[J]. arXiv preprint arXiv:2508.09124, 2025. generally lack scalability, making it difficult to generate ultra-long trajectories that cover a large time span and are logically coherent, resulting in synthesized data often exhibiting short-term fragmented characteristics. Secondly, existing trajectory synthesis algorithms [3] Wu D, Wang H, Yu W, et al. Longmemeval: Benchmarking chat assistants on long-term interactive memory[J].arXiv preprint arXiv:2410.10813, 2024. [4] Chen D, Niu S, Li K, et al. Halumem: Evaluating hallucinations in memory systems of agents[J]. arXivpreprint arXiv:2511.03506, 2025. have obvious drawbacks in deep fusion of multi-source heterogeneous datasets. The current conventional approach is usually to synthesize local trajectories of short length and then sample fragments of data that do not conflict with the target individual from the existing dialogue dataset and simply splice them together. This sampling-based splicing method lacks deep logical connections and macro-level guidance at the knowledge level, making the synthesized trajectory inadequate in evaluating the accumulation of agent capabilities and long-term temporal evolution.

[0004] In summary, the current field of artificial intelligence urgently needs an experience synthesis framework that can overcome scalability bottlenecks, deeply integrate multi-source domain knowledge, and ensure long-term temporal consistency. This framework should be able to organically transform fragmented, scattered session data into hierarchical, knowledge-guided long-term interaction trajectories. In this way, high-quality data benchmarks can be provided for evaluating the performance of large model memory systems in realistic, complex, and evolutionary scenarios, thereby truly measuring the evolutionary capabilities of intelligent agents in assisting users to complete complex tasks. Summary of the Invention

[0005] In view of the above, and in response to the technical challenges of insufficient scalability of individual interaction trajectory synthesis in existing technologies and the difficulty in effectively integrating multi-source fragmented conversations into long-term evolutionary trajectories, this invention proposes a knowledge-guided evolutionary memory experience synthesis method and system based on hierarchical recursive divide-and-conquer. This invention is no longer limited to simple anthropomorphic user profile modeling, but rather comprehensively evaluates and improves the memory retrieval and service evolution capabilities of intelligent agents in assisting users to complete complex engineering tasks by constructing interaction trajectories covering a long time series.

[0006] To achieve the above-mentioned objectives, an embodiment provides a knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer, comprising the following steps: Initialize the synthesis environment and data model system for constraint trajectory generation; Initialization of the temporal event graph: Using the graph extension agent, a temporal event subgraph with a high-level narrative structure is constructed within the target time span based on the current user profile or parent node events; Parent node data allocation: The session-based agent distributes the external session data carried by the parent node to the nodes of the time-series event subgraph according to the time interval inclusion relationship. Node expansion is performed in topological order: Each event node is traversed according to the topological order of the time-series event subgraph. The graph expansion agent or session is used to determine and execute the expansion of the traversed event nodes into a more fine-grained time-series event subgraph or to construct a specific session. Dynamic graph structure refinement and optimization: The graph refinement agent optimizes subsequent unexpanded event nodes in the graph in real time based on the current expansion results to eliminate potential context conflicts and enhance logical coherence; Iterative execution follows the topological order to expand nodes and refine and optimize the dynamic graph structure until all event nodes in the time-series event subgraph are expanded into indivisible leaf nodes, forming a hierarchical interaction trajectory tree. Bottom-up question-answer pair synthesis: Based on a hierarchical interaction trajectory tree, question-answer pair datasets are recursively synthesized from the leaf nodes at the bottom to the root nodes at the top. Multi-stage quality control: The hierarchical interaction trajectory tree and question-and-answer dataset are deduplicated, rewritten, conflict detected, and finally verified to obtain the evolutionary memory experience dataset.

[0007] Preferably, when initializing the synthesis environment, user profiles, external session sets, and target time spans are also defined. The data model system is based on a data validation framework, specifically including a personality profile data model for converting user profiles into fixed-format data; a time-series event graph model, an event model, and an edge model for constraining the construction of agents or expanding time-series event subgraphs; a requirement model for implementing cross-level synthesis guidance; and a session and message model for constraining the working time of session-building agents or session-implementing agents, forcing message sequences to have strict unidirectional increasing characteristics. Preferably, a question type toolkit is also initialized, containing predefined evaluation dimensions and their corresponding unique names and detailed descriptions. The evaluation dimensions include single-hop recall, multi-hop reasoning, time-series reasoning, relationship understanding, adversarial question answering, and query-oriented overview.

[0008] Preferably, during the initialization of the time-series event graph, the graph extension agent acts as a recursive planner, initializing the time-series event subgraph based on the current user profile or parent node events. Specifically, this includes: for the current user profile, converting it into a personality profile data model and inputting it into the graph extension agent; for the parent node events, directly inputting them into the graph extension agent; the graph extension agent outputs function call tools to create event models and edge models, and converting the event models and edge models into time-series event subgraphs through the time-series event graph model, wherein the current user profile serves as the root node.

[0009] Preferably, when allocating data to the parent node, the session landing agent searches for a target event node by performing a time interval search, ensuring that the time interval of the external session data is completely contained within the time boundary of the target event, thus completing the data allocation. If a matching target event cannot be found, the session landing agent will actively modify the time-series event subgraph structure to ensure that each external session can find a target event node as a logical anchor point in the synthetic trajectory. Modifying the time-series event subgraph structure includes adjusting the timestamp or adding nodes.

[0010] Preferably, when performing node expansion in topological order, if it is determined that the traversed event node needs further refinement, the process recursively calls itself to expand the currently traversed event node into a more granular temporal event subgraph; if it is decided to expand the event node into a session, the session building agent is called to synthesize a specific human-computer dialogue based on the anchored external session or event content; if multiple external sessions are anchored to the same event, the multiple external sessions are connected.

[0011] Preferably, during dynamic graph structure refinement and optimization, after each event node expansion action is completed, the graph refinement agent is immediately triggered and granted tool permissions to add, delete, or modify future event nodes and edges to eliminate potential contextual conflicts and enhance logical coherence, specifically including: Based on the currently generated incremental context, the attributes of subsequent unexpanded event nodes are adjusted in real time, and the new information is distributed to the subsequent event nodes. In addition, hard time constraints are enforced to ensure that the end time of the source event is strictly earlier than the start time of the target event it is connected to, and the generation results of the expanded nodes are distributed to the subsequent nodes as immutable states.

[0012] Preferably, in the bottom-up question-answer pair synthesis, the question-answer pair building agent starts from the leaf nodes of the hierarchical interaction trajectory tree and first generates basic question-answer pairs around a specific dimension. When processing internal nodes, the question-answer pairs generated by their child nodes are used as basic building blocks. Through cross-session information aggregation and logical association reasoning, more challenging multi-hop reasoning and long-term timeline complex question-answer pairs are synthesized. In this process, the child question-answer pairs generated by the child nodes that have not been aggregated are randomly sampled and passed to higher levels along with the newly synthesized complex question-answer pairs, until they reach the profile level of the root node, thus obtaining the question-answer pair dataset.

[0013] Preferably, in multi-stage quality control, the first step is rule-level verification, which merges overlapping sessions caused by independent event scheduling, and manually samples the trajectories to correct obvious errors. The second step is model-level evaluation, which uses a large language model to verify the sufficiency of evidence for question-answer pairs, identifies and removes redundant or overly similar instances, and low-quality or insufficiently evidenced question-answer pairs will enter an automatic rewriting process. Finally, human experts review the data to eliminate potential human intervention, ensuring that the final output evolutionary memory dataset meets high standards in terms of authenticity, logic, and evaluation validity.

[0014] To achieve the above-mentioned objectives, embodiments of the present invention also provide a knowledge-guided evolutionary memory experience synthesis system based on hierarchical recursive divide-and-conquer, comprising: The initialization module is used to initialize the synthesis environment and data model system for constraint trajectory generation. The recursive trajectory synthesis engine includes four types of agents: graph expansion agent, graph refinement agent, session landing agent, and session building agent. These agents work together to execute a complete recursive loop from initializing the time-series event subgraph to expanding nodes and then dynamically refining them, generating a hierarchical interaction trajectory tree. The hierarchical question-answer pair synthesis module is used to recursively synthesize question-answer pair datasets from the leaf nodes at the bottom level to the root node at the top level, based on a hierarchical interaction trajectory tree. The closed-loop quality assurance module integrates automated verification tools and human interaction interfaces to perform deduplication, rewriting, conflict detection, and final verification on the hierarchical interaction trajectory tree and question-and-answer dataset, ensuring that the output evolutionary memory experience dataset meets the requirements of high fidelity and logical rigor.

[0015] Compared with the prior art, the beneficial effects of the present invention include at least the following: To address the shortcomings of existing intelligent agent interaction trajectory synthesis methods in generating long-range evolutionary trajectories, such as insufficient scalability, difficulty in effectively integrating fragmented multi-source conversations, and lack of long-range temporal logic consistency, this invention constructs a temporal event graph and allocates data. It utilizes a graph-extending agent to initialize the subgraph skeleton, and a conversation-implementing agent precisely anchors external fragmented conversations to corresponding sub-event nodes. Hierarchical recursive node expansion is performed, dynamically refining nodes into deeper-level subgraphs or calling conversation-constructing agents to synthesize specific human-computer dialogue messages. A dynamic graph structure refinement mechanism is introduced, triggering a graph refinement agent in real-time after expansion, eliminating potential contextual conflicts by adjusting future nodes and enforcing time constraints. A bottom-up question-and-answer pair synthesis algorithm is implemented, recursively aggregating from leaf nodes to root nodes based on a trajectory tree structure to generate complex question-and-answer pairs covering single-hop recall, multi-hop inference, and long-range temporal dimensions. Multi-stage quality control is implemented, ensuring data rigor through automated rule verification, model consistency verification, and human expert review.

[0016] This invention achieves a smooth transition from macro-narrative planning to micro-dialogue generation through a planning-execution recursive workflow, ensuring the coherence and knowledge depth of the synthesis trajectory over a long period, and significantly improving the synthesis efficiency and evaluation effectiveness of AI memory system evolution experience data. Attached Figure Description

[0017] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0018] Figure 1 This is a flowchart of knowledge-guided evolutionary memory experience synthesis based on hierarchical recursive divide-and-conquer provided in the embodiment; Figure 2 This is a flowchart of the knowledge-guided evolutionary memory experience synthesis based on hierarchical recursive divide-and-conquer provided in the embodiment; Figure 3 This is a schematic diagram of the structure of the knowledge-guided evolutionary memory experience synthesis system based on hierarchical recursive divide-and-conquer provided in the embodiment. Detailed Implementation

[0019] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and do not limit the scope of protection of this invention.

[0020] The inventive concept of this invention is as follows: This embodiment provides a knowledge-guided evolutionary memory experience synthesis scheme based on hierarchical recursive divide-and-conquer. It aims to overcome the limitations of existing intelligent agent interaction trajectory synthesis in generating interactive data with long-term consistency, long-range evolution, scalability, multi-domain knowledge fusion (such as mathematical datasets, code datasets, etc.), and complex task processing capabilities through a systematic synthesis framework. Specifically, it constructs a hierarchical recursive planning-execution workflow to decompose the long-term trajectory synthesis task into multiple interconnected and conflict-free short trajectory subtasks.

[0021] like Figure 1 and Figure 2 As shown in the embodiment, the knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer includes the following steps: S1, Initialize the synthesis environment: Configure user profiles, external session sets, and target time span.

[0022] To ensure the robustness of the synthesis process and facilitate automated verification, this invention first defines a data model system based on the data verification framework (Pydantic). Pydantic is a data verification and parsing library based on Python type annotations, which supports functions such as automatic verification, type conversion, nested models, import and export, and configuration management. Specifically, (1) in the global identity and attribute evolution dimension, this invention constructs a personality profile data model to convert user profiles into fixed format data. This personality profile data model adopts a composite design pattern and is composed of multiple independent dimension models such as basic information and occupation. The variable fields under each dimension have the feature of "version tracking". The key connection fields are used to logically anchor the field change history with the specific session message ID, and record the last modification time and the corresponding operation log, ensuring the consistency and traceability of the user profile in the long-term evolution process.

[0023] (2) In the space-time dependent logical planning dimension, this invention constructs a time-series event graph model and uses a directed acyclic graph structure to organize event nodes at the same level. Each event node is an event model, which are connected together by edge models. The topological sorting algorithm built into the time-series event graph model automatically calculates the event expansion priority. Combined with the nested verification of time intervals, the time-series conflicts between events are eliminated from the underlying architecture.

[0024] (3) In the dimension of knowledge guidance and generation constraints, this invention constructs a requirement model as a medium for information transmission between levels to achieve cross-level synthesis guidance. Each constraint indicates whether it originates from ancestor events, global profiles or the agent's own logical deduction through the source field, and uses the source evidence field to forcibly associate it with the original fact fragments to ensure that the sub-events generated in the hierarchical recursion process do not deviate from the preset knowledge path.

[0025] (4) In terms of atomic-level execution and task verification, this invention utilizes a session and message model to perform physical and logical verification of the underlying interaction trajectory. By monitoring the timestamp field in real time, it enforces that the message sequence has a strict unidirectional incremental characteristic. The entire method flow of this invention runs based on a rigorous data model defined by Pydantic, ensuring the robustness and controllability of the agents in the method during tool invocation.

[0026] The initialization of the synthesis environment also involves acquiring an initial user profile, an external session set, and a target time span. The initial user profile can be a real user profile mapped to the personality profile data model definition system of this invention; that is, by extracting the basic attributes, professional background, and behavioral characteristics of real individuals and structurally converting them into the personality profile data model of this invention. Alternatively, the initial user profile can be a synthesized user profile, for example, based on a large language model, performing multi-dimensional attribute expansion and semantic filling on seed characters in open-source profile libraries such as PersonaHub, and accurately mapping them to the personality profile data model definition system of this invention to generate a virtual personality prototype with rich prior knowledge. The external session set contains various heterogeneous session data, which is used to evolve into interaction trajectory data. The target time span defines the time span of the interaction trajectory data.

[0027] During initialization, the synthesis process is formalized as a two-stage pipeline: the first stage generates long-range interaction trajectories, and the second stage constructs question-answer pairs based on the trajectories. Simultaneously, a question type toolkit is initialized, containing predefined evaluation dimensions and their corresponding unique names and detailed descriptions. These evaluation dimensions include single-hop recall, multi-hop reasoning, temporal reasoning, relational understanding, adversarial question answering, and query-oriented overview.

[0028] The embodiment also defines four collaborative expert agents: (1) Graph expansion agent: as a recursive planner, responsible for dynamically expanding the parent event node into a more granular temporal event subgraph and controlling the task decomposition process according to the topological order; (2) Graph refinement agent: triggered in real time after each event node is expanded, and by adding, deleting or modifying future nodes, it eliminates the context conflicts introduced during the expansion process and ensures the global coherence and temporal consistency of the trajectory; (3) Session landing agent: responsible for accurately anchoring the session content in the heterogeneous external session set to the specific event boundary of the subgraph, realizing the lossless fusion of the existing high-quality knowledge base and the synthetic trajectory; (4) Session construction agent: performs specific human-computer dialogue generation at the leaf nodes of the trajectory tree, and transforms abstract events into executable interactive records.

[0029] S2, Initialization of the temporal event graph: Using the graph-extended agent, a temporal event subgraph with a high-level narrative structure is constructed within the target time span based on the current user profile and parent node events.

[0030] In this embodiment, the initialization of the temporal event graph is led by a graph extension agent. This agent, acting as a recursive planner, is responsible for executing the core logic of the divide-and-conquer strategy. Specifically, it initializes the temporal event subgraph based on the target time span and the current user profile and / or parent node events. During this process, the current user profile is transformed into a personality profile data model and injected into the graph extension agent as a global state constraint. Similarly, parent node events during the iteration process are also input into the graph extension agent. The agent outputs function call tools to create event and edge models, and then transforms these models into temporal event subgraphs through the temporal event graph model. The current user profile serves as the root node, ensuring strict logical consistency between the synthesized sub-event sequence and the user's personality traits, established facts, and lifestyle habits, preventing logical inconsistencies between synthesized events and user profile attributes (such as professional background or social relationships). This profile constraint mechanism is effective at every level of the recursive synthesis, including the skeleton construction in the graph initialization phase, the session implementation phase, and the detailed expansion in the sub-event expansion phase, thus ensuring consistency throughout the entire path from top-level planning to bottom-level execution.

[0031] S3, Parent Node Data Allocation: The session landing agent uses the external session data carried by the parent node to allocate the data to the nodes of the time-series event subgraph according to the time interval inclusion relationship.

[0032] In this embodiment, a session-implementing agent is used to address the fusion problem of fragmented external data. The session-implementing agent is responsible for distributing external session data inherited from the parent node to the constructed time-series event subgraph. The agent performs data distribution using a time interval matching algorithm. Specifically, it searches for a target event node by performing a time interval search, ensuring that the time interval of the external session data is completely contained within the time boundary of the target event. If no matching target event can be found, i.e., there is no matching event node in the subgraph that satisfies the time constraint, the session-implementing agent has the authority to modify the subgraph topology, including adjusting timestamps or adding nodes. It actively modifies the time-series event subgraph structure by dynamically creating carrier nodes or adjusting the boundaries of existing nodes, ensuring that all external sessions inherited from the parent node can be effectively anchored, i.e., ensuring that each external session can find a target event node as a logical anchor point in the synthesis trajectory.

[0033] S4, Execute node expansion in topological order: Traverse each event node according to the topological order of the time-series event subgraph, and use graph expansion agents or session construction agents to judge and execute the expansion of the traversed event nodes into a more fine-grained time-series event subgraph, or to construct a specific session.

[0034] In this embodiment, the nodes in the time-series event subgraph are traversed according to their topological order. The graph-expanding agent evaluates the complexity of events based on autonomous logical reasoning rules. By analyzing the relationships between people involved in the event content, semantic richness, and evolutionary potential, it dynamically determines whether the node has value for further refinement. This invention also supports forced expansion based on a preset time threshold. If the time interval covered by the current event node exceeds the user-specified threshold (e.g., one day), decomposition logic is triggered. If the interval length is less than the threshold, it is expanded into a session. Furthermore, it can also support complex judgment rules based on multi-dimensional feature combinations, comprehensively considering the density of external session anchors and the weight of nodes in the global narrative to ensure the flexibility and rationality of the decomposition process. When it is determined that the traversed event node needs further refinement, it recursively calls itself, that is, recursively triggers a new round of subgraph construction process, expanding the currently traversed event node into a more granular temporal event subgraph; if it is decided to expand the event node into a session, the session construction agent is called to synthesize the specific human-computer dialogue message stream based on the anchored external session or event content, and obtain the specific session. If there are multiple external sessions anchored to the same event, the multiple external sessions are connected and processed, thereby achieving a seamless connection from macro-narrative planning to micro-dialogue execution.

[0035] S5, Dynamic Graph Structure Refinement and Optimization: Utilize the graph refinement agent to perform real-time optimization of subsequent unexpanded event nodes in the graph based on the current expansion results, thereby eliminating potential contextual conflicts and enhancing logical coherence.

[0036] To prevent logical conflicts arising when independent events are generated, this invention introduces a graph refinement agent responsible for maintaining global consistency during the synthesis process. After each event node's expansion action is completed, the graph refinement agent is immediately triggered and granted tool permissions to add, delete, or modify future event nodes and edges to eliminate potential contextual conflicts and enhance logical coherence. Specifically, this includes: By analyzing the generated incremental context information, potential logical conflicts on subsequent paths are predicted, and the graph structure is updated in real time using a tool interface. This involves adjusting the attributes of subsequent unexpanded event nodes in real time by adding, deleting, or modifying them, and distributing the new information to subsequent event nodes. At the same time, hard time constraints are enforced, meaning that the termination time of any source event node must be earlier than the start time of all subsequent target event nodes connected to it, and the generation results of expanded nodes are distributed to subsequent nodes as immutable states. This prevents time backtracking or logical breaks during the generation process, thereby ensuring the temporal rigor of the overall trajectory.

[0037] S6 iteratively executes node expansion and dynamic graph structure refinement and optimization in topological order until all event nodes in the time sequence event subgraph are expanded into indivisible leaf nodes, forming a hierarchical interaction trajectory tree.

[0038] When iterating through steps S4 and S5 above, the process continues until all event nodes in the initial time-series event subgraph are expanded into indivisible leaf nodes, forming a complete hierarchical interaction trajectory tree. This hierarchical interaction trajectory tree includes the image level at the root node, the event subgraph level at the intermediate nodes, and the session level at the leaf nodes.

[0039] S7, Bottom-up question-answer pair synthesis: Based on a hierarchical interaction trajectory tree, question-answer pair datasets are synthesized recursively from the leaf nodes at the bottom layer to the root node at the top layer.

[0040] In this embodiment, a bottom-up aggregation algorithm is employed, fully utilizing the hierarchical tree structure formed during trajectory synthesis to generate the question-answer pair dataset. The specific question-answer pair building agent starts from the leaf nodes (i.e., specific sessions) of the hierarchical interaction trajectory tree, first generating basic question-answer pairs (i.e., single-hop problems) around a specific dimension (such as a person's profile or details of a single event). When processing internal nodes (i.e., event subgraphs), the question-answer pairs generated by their child nodes are used as basic building blocks. Through cross-session information aggregation and logical association reasoning, more challenging multi-hop reasoning and long-term timeline complex question-answer pairs are synthesized. During this process, child question-answer pairs generated by child nodes that are not aggregated are randomly sampled and passed to higher levels along with the newly synthesized complex question-answer pairs, until reaching the profile level of the root node, thus obtaining the question-answer pair dataset.

[0041] Furthermore, the agent can dynamically expand the problem type reference book based on the evolution characteristics of the trajectory during the synthesis process, allowing the introduction of new evaluation dimensions to adapt to the interaction needs of different domains.

[0042] S8, multi-stage quality control: the hierarchical interaction trajectory tree and question-answer pair dataset are deduplicated, rewritten, conflict detected and finally verified to obtain the evolutionary memory experience dataset.

[0043] The implementation employs a multi-stage quality assurance pipeline, specifically including rule-level conflict resolution, model-level semantic evaluation, and human expert review. The multi-stage quality control first involves rule-level verification, using hard rules to detect temporal overlaps caused by simultaneously occurring independent events, and optimizing this through a session merging strategy. Specifically, overlapping sessions caused by the scheduling of independent events are merged, and the trajectories are manually sampled and checked to correct obvious errors. Second, model-level evaluation utilizes a large language model with strong reasoning capabilities to verify the sufficiency of evidence in the generated question-answer pairs, ensuring that the answer to each question can find clear supporting evidence in the trajectory data. Specifically, the large language model verifies the sufficiency of evidence in the question-answer pairs, identifying and removing redundant or overly similar instances. Low-quality or insufficiently evidenced question-answer pairs enter an automatic rewriting process and undergo a final reliability review by human experts. Finally, human expert review eliminates potential human intervention, ensuring that the final output evolutionary memory experience dataset meets high standards in terms of authenticity, logic, and evaluation validity. The evolutionary memory experience dataset includes the quality-controlled interaction trajectories and question-answer pairs.

[0044] like Figure 3 As shown, the embodiment also provides a knowledge-guided evolutionary memory experience synthesis system 30 based on hierarchical recursive divide-and-conquer, including: Initialization module 31 is used to initialize the synthesis environment and data model system for constraint trajectory generation, i.e., to execute the above step S1; The recursive trajectory synthesis engine 32 includes a graph expansion agent, a graph refinement agent, a session landing agent, and a session construction agent. These four types of agents work together to execute a complete recursive loop from the initialization of the time-series event subgraph to the node expansion and dynamic refinement, generating a hierarchical interaction trajectory tree, i.e., executing the above steps S2-S6. The hierarchical question-answer pair synthesis module 33 is used to recursively synthesize the question-answer pair dataset from the leaf nodes at the bottom layer to the root node at the top layer based on the hierarchical interaction trajectory tree, that is, to perform the above step S7. The closed-loop quality assurance module 34 integrates automated verification tools and human interaction interfaces to perform deduplication, rewriting, conflict detection, and final verification on the hierarchical interaction trajectory tree and question-and-answer dataset, ensuring that the output evolutionary memory experience dataset meets the requirements of high fidelity and logical rigor, i.e., performing the above step S8.

[0045] It should be noted that the knowledge-guided evolutionary memory experience synthesis system based on hierarchical recursive divide-and-conquer provided in the above embodiments should be illustrated using the above-described functional module divisions as examples when performing knowledge-guided evolutionary memory experience synthesis. The functions can be assigned to different functional modules as needed, i.e., the internal structure of the terminal or server can be divided into different functional modules to complete all or part of the functions described above. Furthermore, the knowledge-guided evolutionary memory experience synthesis system and the knowledge-guided evolutionary memory experience synthesis method embodiments provided in the above embodiments belong to the same concept; their specific implementation process is detailed in the knowledge-guided evolutionary memory experience synthesis method embodiments, and will not be repeated here.

[0046] The specific embodiments described above illustrate the technical solution and beneficial effects of the present invention in detail. It should be understood that the above description is only the most preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, additions, and equivalent substitutions made within the scope of the principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer, characterized in that, Includes the following steps: Initialize the synthesis environment and data model system for constraint trajectory generation; Initialization of the temporal event graph: Using the graph extension agent, a temporal event subgraph with a high-level narrative structure is constructed within the target time span based on the current user profile or parent node events; Parent node data allocation: The session-based agent distributes the external session data carried by the parent node to the nodes of the time-series event subgraph according to the time interval inclusion relationship. Node expansion is performed in topological order: Each event node is traversed according to the topological order of the time-series event subgraph. The graph expansion agent or session is used to determine and execute the expansion of the traversed event nodes into a more fine-grained time-series event subgraph or to construct a specific session. Dynamic graph structure refinement and optimization: The graph refinement agent optimizes subsequent unexpanded event nodes in the graph in real time based on the current expansion results to eliminate potential context conflicts and enhance logical coherence; Iterative execution follows the topological order to expand nodes and refine and optimize the dynamic graph structure until all event nodes in the time-series event subgraph are expanded into indivisible leaf nodes, forming a hierarchical interaction trajectory tree. Bottom-up question-answer pair synthesis: Based on a hierarchical interaction trajectory tree, question-answer pair datasets are recursively synthesized from the leaf nodes at the bottom to the root nodes at the top. Multi-stage quality control: The hierarchical interaction trajectory tree and question-and-answer dataset are deduplicated, rewritten, conflict detected, and finally verified to obtain the evolutionary memory experience dataset.

2. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 1, characterized in that, When initializing the synthesis environment, user profiles, external session sets, and target time spans are defined. The data model system is based on a data validation framework, which includes a personality profile data model for converting user profiles into fixed-format data, a time-series event graph model, an event model, and an edge model for constraining the construction of agents or expanding time-series event subgraphs, a requirement model for implementing cross-level synthesis guidance, and a session and message model for constraining the working time of session-building agents or session-implementing agents, requiring message sequences to have strict unidirectional increasing characteristics.

3. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 1, characterized in that, It also initializes a question type toolkit, which contains predefined evaluation dimensions and their corresponding unique names and detailed descriptions. The evaluation dimensions include single-hop recall, multi-hop reasoning, temporal reasoning, relational understanding, adversarial question answering, and query-oriented overview.

4. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 2, characterized in that, During the initialization of the time-series event graph, the graph extension agent acts as a recursive planner, initializing the time-series event subgraph based on the current user profile or parent node events. Specifically, for the current user profile, it is transformed into a personality profile data model and then input into the graph extension agent; for parent node events, they are directly input into the graph extension agent. The graph extension agent outputs function call tools to create event models and edge models, and then transforms the event models and edge models into time-series event subgraphs through the time-series event graph model, where the current user profile serves as the root node.

5. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 1, characterized in that, When allocating data to the parent node, the session landing agent searches for a target event node by performing a time interval search, ensuring that the time interval of the external session data is completely contained within the time boundary of the target event, thus completing the data allocation. If a matching target event cannot be found, the session landing agent will proactively modify the time-series event subgraph structure to ensure that each external session can find a target event node as a logical anchor point in the synthetic trajectory. Modifying the time-series event subgraph structure includes adjusting timestamps or adding nodes.

6. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 1, characterized in that, When performing node expansion in topological order, if it is determined that the traversed event node needs further refinement, it recursively calls itself to expand the currently traversed event node into a more granular temporal event subgraph. If it is decided to expand the event node into a session, the session building agent is called to synthesize a specific human-computer dialogue based on the anchored external session or event content. If multiple external sessions are anchored to the same event, the multiple external sessions are connected.

7. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 1, characterized in that, During dynamic graph structure refinement and optimization, after each event node's expansion action is completed, the graph refinement agent is immediately triggered and granted tool permissions to add, delete, or modify future event nodes and edges to eliminate potential contextual conflicts and enhance logical coherence. Specifically, this includes: Based on the currently generated incremental context, the attributes of subsequent unexpanded event nodes are adjusted in real time, and the new information is distributed to the subsequent event nodes. In addition, hard time constraints are enforced to ensure that the end time of the source event is strictly earlier than the start time of the target event it is connected to, and the generation results of the expanded nodes are distributed to the subsequent nodes as immutable states.

8. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 1, characterized in that, In bottom-up question-and-answer pair synthesis, the question-and-answer pair building agent starts from the leaf nodes of the hierarchical interaction trajectory tree, first generating basic question-and-answer pairs around a specific dimension. When processing internal nodes, the question-and-answer pairs generated by their child nodes are used as basic building blocks. Through cross-session information aggregation and logical association reasoning, more challenging multi-hop reasoning and long-term timeline complex question-and-answer pairs are synthesized. During this process, child question-and-answer pairs generated by child nodes that have not been aggregated are randomly sampled and passed to higher levels along with the newly synthesized complex question-and-answer pairs, until they reach the profile level of the root node, thus obtaining the question-and-answer pair dataset.

9. The knowledge-guided evolutionary memory experience synthesis method based on hierarchical recursive divide-and-conquer as described in claim 1, characterized in that, In multi-stage quality control, the first step is rule-level verification, merging overlapping sessions caused by independent event scheduling, and manual sampling inspection of the trajectory to correct obvious errors. Secondly, model-level evaluation is conducted, using large language models to verify the sufficiency of evidence for question-answer pairs, identifying and removing redundant or overly similar instances, and low-quality or insufficiently evidenced question-answer pairs will enter an automatic rewriting process; finally, human experts review the data to eliminate potential human intervention, ensuring that the final output evolutionary memory dataset meets high standards in terms of authenticity, logic, and evaluation validity.

10. A knowledge-guided evolutionary memory experience synthesis system based on hierarchical recursive divide-and-conquer, comprising: The initialization module is used to initialize the synthesis environment and data model system for constraint trajectory generation. The recursive trajectory synthesis engine includes four types of agents: graph expansion agent, graph refinement agent, session landing agent, and session building agent. These agents work together to execute a complete recursive loop from the initialization of the temporal event subgraph to node expansion and dynamic refinement, generating a hierarchical interaction trajectory tree. The hierarchical question-answer pair synthesis module is used to recursively synthesize question-answer pair datasets from the leaf nodes at the bottom level to the root node at the top level, based on a hierarchical interaction trajectory tree. The closed-loop quality assurance module integrates automated verification tools and human interaction interfaces to perform deduplication, rewriting, conflict detection, and final verification on the hierarchical interaction trajectory tree and question-and-answer dataset, ensuring that the output evolutionary memory experience dataset meets the requirements of high fidelity and logical rigor.

Images