System and method for generating enhanced temporal graph retrieval for financial intelligence

Abstract

This disclosure relates to a system and method for generative augmented temporal graph retrieval for financial intelligence. The computer system models a constantly changing corpus as a two-layer temporal graph, comprising a temporal knowledge graph with timestamped relationships and a hierarchical temporal graph with nested time nodes, connected by cross-layer edges. The system indexes documents by extracting time quadruples, generates multi-granular temporal summaries, and stores vector embeddings of entities and relationships. During querying, it determines the time range, retrieves semantically similar subgraphs filtered to that range, scores nodes and edges using graph propagation, selects time-valid segments and summaries, and assembles chronologically ordered hints within a token budget for generation by a large language model. Incremental updates process only new documents, merge timestamped facts, create time nodes on demand, and regenerate affected summaries along ancestor paths; optional validation of numerical and temporal outputs is also possible.

Description

Technical Field

[0001] This application relates to the field of computer science, and more particularly to data processing in the field of financial intelligence, for example, to a computer-implemented system and method for generating enhanced time-map retrieval. Background Technology

[0002] Modern financial markets generate a vast amount of dynamic, time-sensitive information, including company documents, earnings call transcripts, analyst reports, and macroeconomic indicators. These datasets are constantly evolving, making it difficult for static knowledge retrieval systems to maintain temporal accuracy and consistency. Knowledge is inherently time-sensitive and continuously evolves over time.

[0003] However, while traditional Retrieval-Augmented Generation (RAG) systems extend large language models with external knowledge sources, they are primarily insensitive to time. This presents two challenges for RAG. First, current RAG systems have weak time-aware representation capabilities. The same facts at different times are difficult to distinguish using vector embeddings or traditional knowledge graphs. Second, evaluations typically assume the corpus is static, thus creating blind spots regarding update costs and retrieval stability during knowledge development.

[0004] These limitations are particularly problematic in financial applications, where knowledge evolves rapidly and time-based reasoning (e.g., trend analysis, year-over-year comparisons, and regulatory changes) is crucial. Therefore, a time-aware RAG architecture is needed that can efficiently represent evolving knowledge, support incremental updates, and retrieve time-consistent evidence. Summary of the Invention

[0005] The following abstract is intended to introduce some concepts in a simplified form, which will be further explained in the detailed description below. This abstract is not intended to identify key or essential features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter.

[0006] The purpose of some embodiments of this disclosure is to provide a computer-implemented system and method for generating enhanced time-map retrieval.

[0007] On one hand, some embodiments of this disclosure provide a computer-implemented system for generating enhanced time-map retrieval, including:

[0008] An ingestion module is configured to ingest a document corpus and extract time quadruples from the corpus, each time quadruple including a first entity, a second entity, a relation, and a normalized timestamp;

[0009] A building module is configured to build a two-layer time graph, which includes a time knowledge layer and a hierarchical time layer. The time knowledge layer has entity nodes annotated with timestamps and relation edges, and the hierarchical time layer arranges timestamps into nested time nodes.

[0010] The summary module is configured to generate a time summary for each time node in the hierarchical time layer by aggregating the relationships linked to the time nodes;

[0011] The query module is configured to receive natural language queries and identify a time range, which includes one or more time nodes corresponding to a time map.

[0012] A retrieval module configured to retrieve a subgraph of the two-layer time graph that is relevant to the query;

[0013] An assembly module configured to assemble contextual hints, the contextual hints including evidence derived from retrieved subgraphs arranged in chronological order; and

[0014] A generation module is configured to use a large language model to generate a response to the natural language query, the large language model being trained by the contextual hints.

[0015] In some embodiments, extracting time quadruples includes using domain-specific templates to prompt the financial big language model to identify entity, relation, and quantity representations.

[0016] In some embodiments, the time knowledge layer preserves multiple parallel relationship edges between the same entity pair under different timestamps as different time edges.

[0017] In some embodiments, the system is configured to perform incremental updates when a new document arrives by selectively extracting time quadruples from the new document, merging the extracted quadruples into the existing time knowledge graph, creating new time nodes in the hierarchical time layer only when encountering previously unseen timestamps, and regenerating summaries for new leaf time nodes and propagating the updated summaries along ancestor paths.

[0018] In some embodiments, retrieving the subgraph includes: calculating a query embedding, sorting relation edges by the cosine similarity between the query embedding and a pre-calculated relation embedding, filtering the sorted edges to retain only those with timestamps within the identified time range, and collecting neighboring entities of time-valid edges to form a seed set, which is used for graph-based relevance propagation.

[0019] In some embodiments, the retrieval module is configured as follows:

[0020] Local retrieval is performed by running a personalized sorting algorithm on the subgraph using a seed set as personalized vector pairs. Each edge is scored based on the endpoint entity score multiplied by a time indicator, where the edge timestamp is one if it is within the time range and zero otherwise. Block scores are derived from the scores of relevant edges and semantic similarity, and the block with the highest score is selected until the token budget is reached.

[0021] In some embodiments, the generation module is configured to verify the generated response by applying rule-based checks and to use a classifier to label the differences between the generated statement and the underlying quadruple.

[0022] On the other hand, some embodiments of this disclosure also provide a computer-implemented method for generating enhanced time-map retrieval, including:

[0023] One or more processors ingest a document corpus and segment the corpus into timestamp-annotated blocks;

[0024] Extract time quadruples from the block, each time quadruple including a first entity, a second entity, a relation, and a normalized timestamp;

[0025] Construct a time knowledge graph, which includes entity nodes and relation edges annotated with the timestamps;

[0026] Construct a hierarchical timeline, which organizes unique timestamps into nested time nodes;

[0027] Establish cross-layer edges, which connect each time node in the hierarchical time graph to a relation edge in the time knowledge graph, wherein the relation edge is active at the time corresponding to the time node;

[0028] A time summary for each time node is generated by aggregating link relationships and child node summaries using a large language model;

[0029] The system receives natural language queries and determines the time range by extracting time representations from the queries and mapping them to corresponding time nodes.

[0030] The subgraph for a specific query is retrieved by sorting relation edges based on semantic similarity to the query and filtering edges to retain only those within the time range.

[0031] Assemble context hints from the subgraph of the specific query, the context hints being arranged in chronological order; and

[0032] A large language model trained with the contextual cues is used to generate a response to the query.

[0033] In some embodiments, segmenting the corpus includes applying a parser to detect semantic paragraph boundaries.

[0034] In some embodiments, extracting the time quadruple also includes identifying explicit time references and inferring implicit time anchors from context and metadata.

[0035] In some embodiments, the method further includes incrementally updating the time knowledge graph and the hierarchical time graph upon the arrival of a new document by: extracting time quadruples only from the new document; merging the new quadruples into the existing time knowledge graph using a composite key; creating new time nodes in the hierarchical time graph only for timestamps that have not been seen before; generating a summary of the new leaf time nodes; and propagating the summary update along the hierarchical path.

[0036] In some embodiments, retrieving the subgraph further includes: using time-filtered seed entities as personalized vectors, performing local retrieval using a sorting algorithm executed on the subgraph, scoring each relation edge based on the sum of endpoint entity relevance scores multiplied by a time indicator function, and selecting blocks in descending order of block scores until the token budget is reached.

[0037] In some embodiments, the method further includes: performing a global retrieval by collecting time node summaries corresponding to the time range, processing each time node summary independently using a large language model, and synthesizing the time node summaries into a structured answer.

[0038] In some embodiments, the method further includes: validating the generated response by comparing the numerical and temporal representations in the response with retrieved evidence using rule-based validation, and labeling differences using a classifier, wherein the large language model is re-evaluated with additional constraints, and detected inconsistencies trigger regeneration corrections.

[0039] Furthermore, some embodiments of this disclosure also provide a system, including: one or more processors; and one or more computer-readable storage media storing instructions, which, when executed by the one or more processors, cause the system to perform a method, the method comprising:

[0040] Receive document corpus;

[0041] Extract time quadruples from the corpus. Each quadruple includes a first entity, a second entity, a relation, and a timestamp, which is derived from explicit or implicit time stamps in the corpus.

[0042] Construct a two-layer time graph that includes a time knowledge graph and a hierarchical time graph. The time knowledge graph has entity nodes and relation edges with timestamps, and the hierarchical time graph arranges the timestamps into nested intervals.

[0043] Vector embeddings of stored entities and relationships are used to achieve semantic similarity retrieval;

[0044] Time summaries of time nodes in the hierarchical time graph are generated by aggregating and linking facts and summaries via a large language model.

[0045] In response to receiving a natural language query, the system identifies a time range by extracting time representations from the query and mapping them to time nodes, retrieves semantically relevant subgraphs filtered into the time range, performs local retrieval within the time range via graph-based relevance propagation, performs global retrieval by selecting time node summaries corresponding to the time range, assembles chronologically ordered contextual cues from the selected fragments and summaries, and generates a time-consistent answer using a large language model trained on the contextual cues.

[0046] In some embodiments, the method further includes:

[0047] Incremental updates are performed by extracting time quadruples only from newly received documents, merging the extracted quadruples into the time knowledge, creating new time nodes only for previously unseen timestamps, and regenerating summaries of affected time nodes by propagation along hierarchical paths.

[0048] In some embodiments, performing local retrieval includes: running a personalized ranking algorithm on the subgraph using time-filtered seed entities as personalized vectors, multiplying the sum of endpoint entity scores by the time indicator function t as the score for each edge, and deriving block scores from edge scores.

[0049] In some embodiments, performing a global retrieval includes independently processing the collected evidence using the large language model to extract atomic points, iteratively removing the points with the lowest confidence, ranking the remaining points by importance score, and synthesizing the ranked points into a structured analytical response.

[0050] In some embodiments, the method further includes: verifying the generated response through a verification module, the verification module applying rule-based checks to compare the numerical and temporal expressions in the response with retrieved evidence, applying a classifier to label the differences between the generated statement and the underlying four-tuple, and, when a difference is detected, re-providing the large language model with additional constraints through a regeneration correction process.

[0051] In some embodiments, identifying the time range includes: prompting a large language model to extract explicit and implicit time expressions from the query, normalizing the relative time expressions into absolute time intervals using a time normalization engine with financial domain-specific rules, and aligning the normalized intervals to corresponding time nodes in the hierarchical time graph.

[0052] In some embodiments, the disclosed technical means define Temporal Graph Retrieval-Augmented Generation (TG-RAG), which models an external corpus as a two-layer temporal graph consisting of a temporal knowledge graph with timestamped relationships and a hierarchical temporal graph. Multi-granular temporal summaries are generated for each time node to capture key events and broader trends at that time. This design supports incremental updates by extracting new temporal facts from the incoming corpus and incorporating them into the existing graph. The temporal graph explicitly represents the same facts at different times as different edges to avoid ambiguity, and the hierarchical temporal graph allows for the generation of reports only for new leaf time nodes and their ancestors, ensuring effective and efficient updates. During inference, TG-RAG dynamically retrieves subgraphs within the temporal and semantic scope of the query, thereby achieving precise evidence collection.

[0053] These and other features and advantages will become apparent from the following detailed description and the accompanying drawings. It should be understood that the above summary, the following detailed description, and the accompanying drawings are for illustrative purposes only and do not limit the scope of the claims. Attached Figure Description

[0054] Figure 1 A diagram illustrating the challenges of time-based assessment is presented as an example.

[0055] Figure 2 A schematic diagram of the overall architecture of a TG-RAG provided in some embodiments of this disclosure is shown by way of example.

[0056] Figure 3 An illustration of a method for representing and utilizing time information using the TG-RAG approach, provided in some embodiments of this disclosure, is shown by way of example, wherein small subgraphs extracted from a constructed two-layer time map are visualized.

[0057] Figure 4 The following is a pseudocode illustration of a local retrieval algorithm for a TG-RAG system provided in some embodiments of this disclosure, shown by way of example. Detailed Implementation

[0058] The following detailed description, in conjunction with the accompanying drawings, is for illustrative purposes only and is not intended to limit the scope of this embodiment to only this particular construction and implementation. This description explains the functions of each embodiment, as well as the steps for constructing and operating that embodiment. However, the same or equivalent functions and steps can also be achieved through other embodiments.

[0059] When the text refers to phrases such as "an implementation plan," "a specific implementation plan," "an example implementation plan," "an implementation method," "a specific implementation method," "an example," or "a specific example," it indicates that the implementation plan, implementation method, or example may include specific features, structures, or characteristics. However, not every implementation plan, implementation method, or example must include that specific feature, structure, or characteristic. Furthermore, the above expressions do not necessarily refer to the same implementation plan, implementation method, or example. Moreover, when describing a specific feature, structure, or characteristic in conjunction with an implementation plan, implementation method, or example, it should be understood that such a feature, structure, or characteristic can be implemented by combining other implementation plans, implementation methods, or examples, whether explicitly described or not.

[0060] The terminology used herein is for the purpose of describing specific examples only and is not intended to be limiting. As used herein, the singular forms “a,” “an,” and “the” may also be intended to include the plural forms unless the context clearly specifies otherwise. For example, “a” vent may include multiple vents, etc.

[0061] As used herein, the term “and / or” includes any and all combinations of one or more of the associated listed items. Similarly, “or” as used herein is intended to mean an inclusive “or” rather than an exclusive “or.” That is, unless otherwise stated or clearly inferred from the context, “X adopts A or B.” In other words, “X adopts A or B” is satisfied whether X adopts only A, only B, or both A and B.

[0062] Words such as “then” and “next” are not intended to restrict the order of steps; these words are only used to guide the reader through the description of the method.

[0063] The terms "comprising," "including," "having," and "characterized by" are all open-ended expressions, meaning that the stated features, elements, components, steps, values, operations, and / or parts are present, but do not exclude the addition of one or more other features, values, steps, operations, elements, parts, or combinations thereof. When used to describe and limit the various technical solutions described herein, the above open-ended terms are generally understood as non-restrictive; however, in some cases, they can also be interpreted restrictively, for example, as "composed of" or "essentially composed of." Accordingly, for any embodiment described herein involving components, materials, parts, elements, features, values, operations, and / or process steps, embodiments composed of or substantially composed of the stated contents are also covered. Embodiments "composed of" do not include any additional components, materials, parts, elements, features, values, operations, and / or process steps; embodiments "essentially composed of" exclude any additional components, materials, parts, elements, features, values, operations, and / or process steps that have a substantial impact on the basic and innovative features of the solution, but may include other contents that do not have a substantial impact.

[0064] Unless the execution order is explicitly specified, all methods, steps, processes, and operations described in this document should not be construed as requiring execution in a fixed order as described or illustrated herein. Unless otherwise stated, some steps may be added or substituted.

[0065] The technical features described for specific exemplary embodiments can be applied to other exemplary embodiments in any arrangement and combination. Different aspects or components of the exemplary embodiments disclosed herein can also be combined in the manner described above. The terms "combination," "combination form," and similar expressions used herein refer to all permutations and combinations of the foregoing items. For example, "A, B, C, or combinations thereof" is intended to include at least one of A, B, C, AB, AC, BC, or ABC; if the context requires an order, it also includes forms such as BA, CA, CB, CBA, BCA, ACB, BAC, CAB, etc. By way of example, this expression also explicitly covers combinations containing repeating items, such as BB, AAA, AB, BBC, AAABCCCC, CBBAAA, CABABB, etc. Those skilled in the art should understand that, unless the context otherwise specifies, the number of items in a combination is generally not limited.

[0066] The foregoing has described some of the technical solutions of the present invention, but the present invention can be embodied in many different forms and should not be limited to the embodiments disclosed herein. These embodiments are provided to make the content of the present invention complete and comprehensive, and to fully convey the various concepts of the present invention to those skilled in the art.

[0067] Unless otherwise stated, all numerical values ​​described herein are approximate. Therefore, this meaning should be implied even without explicit statement. The numerical values ​​disclosed herein should not be strictly limited to exact values; unless otherwise stated, each value includes the value itself and a range of values ​​with equivalent function. At least, without limiting the application of the equivalence principle to the claims, the interpretation of each value should be based on the significant figures recorded and follow conventional rounding rules. Typically, the numerical error range can be 20%, 10%, or 5% of a given value or range of values. Another interpretation is that "approximately" indicates that the values ​​are on the same order of magnitude, ranging from two to five times the given value. Although the numerical values ​​in this document are approximate, the measured values ​​obtained in specific embodiments will be recorded as accurately as possible. All numerical values ​​themselves have a certain degree of error, which stems from the standard deviation of the corresponding detection method.

[0068] All numerical intervals described in this article include all subintervals within that interval. For example, the interval "1 to 10" includes all subintervals between the minimum value 1 and the maximum value 10, because the numerical intervals disclosed in this article are continuous intervals, covering any value between the maximum and minimum values. Any upper limit of a numerical value described in this article includes all smaller upper limits; any lower limit of a numerical value includes all larger lower limits.

[0069] Features or functions described for specific exemplary embodiments can be applied, either wholly or in parts, to other exemplary embodiments. Similarly, different aspects and components of the exemplary embodiments disclosed herein can also be combined, either wholly or in parts. Some exemplary embodiments can serve as modules of a larger system in which other processes can be prioritized or their application adjusted. Furthermore, several other steps may need to be performed concurrently with, before, or after the exemplary embodiments described herein. It should be noted that all methods and processes described herein can be performed, at least partially, by any entity in any manner.

[0070] The foregoing has illustrated and described some technical solutions; however, those skilled in the art should understand that various modifications and variations can be made without departing from the spirit and scope of this invention. Those skilled in the art can determine numerous equivalent solutions, including alternatives, variations, additions, deletions, modifications, and substitutions, through conventional experiments. Therefore, this application (including the appended claims) aims to cover all modifications and variations falling within the scope of protection of this application.

[0071] Unless otherwise defined, all technical and scientific terms used herein shall have the same meaning as commonly understood by one of ordinary skill in the art.

[0072] Numerous specific details are provided in this document to provide a full understanding of one or more embodiments of the subject matter. However, it should be understood that these embodiments can be practiced without these specific details.

[0073] The following description illustrates an exemplary implementation of a system for Temporal Graph Retrieval Enhancement Generation (TG-RAG). Retrieval-Enhancement Generation (RAG) has emerged as a powerful paradigm for providing external knowledge to large language models (LLMs), which can alleviate LLM challenges such as illusion-limited domain-specific expertise and outdated knowledge. A typical RAG framework comprises three core components: indexing an external corpus into a vector database, retrieving paragraphs semantically similar to the input query, and generating an answer based on the query and the retrieved content. Recent advances, such as GraphRAG, further improve the retrieval process by constructing the original corpus as a knowledge graph. This graph-based representation connects isolated facts through shared entities or relations, enabling multi-hop reasoning and a deeper understanding of the corpus.

[0074] However, existing RAG frameworks neglect the fundamental temporal dimension of knowledge. In real-world scenarios, knowledge is inherently time-sensitive and evolves over time. For example, a company's financial reports present varying revenue figures across different fiscal years, and these figures grow over time as new documents are continuously released. Current RAG systems face significant limitations in representing and retrieving time-sensitive information. For vector-based RAGs, factual statements that differ only in their temporal attributes (e.g., "Company X's revenue in 2021 was $Y1" versus "Company X's revenue in 2022 was $Y2") tend to generate highly similar vector representations, making them difficult to distinguish during retrieval. For graph-based approaches, knowledge graphs represent relational facts through static triples (subject, relation, object). Such time-agnostic triples lack native support for temporal attributes. For example, the above fact would be transformed into two triples (X, revenue, $Y1) and (X, revenue, $Y2) without indicating the time involved.

[0075] Furthermore, the continuous evolution of real-world corpora necessitates that RAG systems support effective and efficient incremental updates. While such updates are crucial in practical deployments, most studies evaluate RAG systems in static corpus settings, where the index is built once and subsequent evaluations measure retrieval and response performance on a fixed database. This leaves critical evaluation blind spots, including the computational costs of updates and performance changes caused by newly ingested information. Typically, RAGs face two fundamental time challenges: (1) how to effectively represent and retrieve time-sensitive knowledge, and (2) how to support knowledge updates at minimal cost while maintaining robust performance.

[0076] refer to Figure 1 This illustrates a schematic diagram of the challenges of time-based assessment.

[0077] To address these challenges, a system and method for Temporal Graph RAG (TG-RAG) are presented as a novel framework that models real-world knowledge through a two-layer temporal graph constructed from a corpus. The lower layer is a temporal knowledge graph whose nodes are entities mentioned in the corpus, and whose edges are relations annotated with timestamps. Relationships between the same entity pairs at different times are preserved as distinct edges, thus capturing historical evolution. The upper layer organizes all timestamps into a hierarchical temporal graph. Cross-layer edges connect each time node to relation edges that are active at that time. For each time node, the system maintains a temporal summary that aggregates the facts attached to that node and summaries of its fine-grained child nodes, resulting in a corpus-level, time-range knowledge view.

[0078] The TG-RAG system is designed to enable time-aware reasoning and efficient incremental updates in financial knowledge environments. The TG-RAG model views the ever-evolving financial corpus as a two-layered temporal knowledge graph, consisting of: a temporal knowledge layer where edges are timestamped to represent factual evolution; a hierarchical time layer that organizes time intervals into nested structures (e.g., year → quarter → month → day); and cross-layer connections that bind time nodes to relationships active within those time periods.

[0079] This structure enables fine-grained time representation, multi-granularity generalization, and low-cost incremental updates as new data is introduced. The time subgraph retrieval mechanism identifies relevant time periods from user queries and dynamically retrieves corresponding subgraphs to construct context.

[0080] When applied to financial data, TG-RAG enables accurate reasoning about evolving facts such as income, earnings, debt ratios, or macroeconomic indicators, and can generate time-consistent, interpretable answers for tasks such as trend summarization, risk analysis, and market intelligence.

[0081] In various implementations, TG-RAG is designed to be update-friendly. When new documents arrive, the TG-RAG system can extract timestamped relationships and incorporate them into an existing graph, then generate summaries only for the new time points, progressively propagating updates to their ancestor time points, thus avoiding costly re-generalization from scratch. For retrieval, two time-aware strategies can be employed: local retrieval extracts fine-grained facts within a specified time window, while global retrieval utilizes time summaries to capture important events or broader trends. In this way, TG-RAG provides effective temporal representation and efficient incremental updates, bridging the gap between traditional RAGs and the temporal nature of real-world knowledge.

[0082] The TG-RAG system may include an ingestion module, a time extraction module, a two-layer time map module, a summarization module, an update module, a query module, a retrieval module, a context and hint construction module, and a generation and verification module.

[0083] For the ingestion module, the TG-RAG system begins with a comprehensive ingestion and normalization process designed to adapt to diverse and continuously updated financial data sources. These sources include company documents such as 10-K and 10-Q reports, earnings call transcripts, analyst research documents, financial news articles, and macroeconomic releases. Each document undergoes a hybrid rule-based and machine learning process for content extraction, encoding normalization, and semantic segmentation. A rule-based parser identifies section headings, table boundaries, and templated text, while a Transformer-based language model detects semantic paragraph boundaries and segments the text into context-preserving blocks. A time-representation recognizer, based on a hybrid regular expression and BERT-based time stamping, identifies explicit time references (e.g., "Q4 2023", "March 2024") and normalizes them to ISO timestamps. Implicit time anchors are inferred using probabilistic context rules and metadata such as release dates. The module's output is a structured dataset of normalized text segments, each containing normalized time annotations, language embeddings, and source metadata.

[0084] The Time Quadruple Extraction Module transforms unstructured financial sentences into structured temporal facts. Extraction is achieved using a combination of large-scale language model inference and symbolic post-processing rules. The extraction follows a two-step approach. First, entities, relations, and associated quantitative expressions are identified using a fine-tuned Large-Scale Financial Language Model (LLM) combined with domain-specific templates. Then, the model applies contextual reasoning to disambiguate financial terms such as “EPS,” “profit margin,” or “income guidance.” Each quadruple carries a confidence score, calculated through integration consistency across multiple model runs and redundancy checks across different documents. The module's output is an empirical list of time-anchored financial facts suitable for graphical representation.

[0085] For the two-layer time graph construction module, validated quadruples are assembled into a second-level time graph, forming the central data representation of the system. The lower layer is built using a graph database infrastructure and may contain a temporal knowledge graph. It contains nodes for entities and edges representing previously extracted temporal relationships. The graph schema compiler automatically defines the node and edge types from the quadruple ontology, ensuring consistency and referential integrity. The upper layer is built using a recursive generation algorithm that organizes time nodes into parent-child relationships, potentially forming a time hierarchy graph. Cross-layer connections are implemented through a hash indexing function that maps each fact edge in the lower layer to its corresponding time node at the finest granularity in the upper layer. This process also uses dense vector embeddings derived from a financial domain encoder to embed text and values, enabling semantic retrieval at query time. The output of this module is graph objects stored in a persistent graph database.

[0086] The summarization module uses a hierarchical LLM generalization to generate human-readable summaries across multiple timescales. For each time point in the hierarchy, the system collects all links, aggregates them by entity and metric, and prompts the LLM to generate a concise summary constrained by a token budget and style template. Summaries are propagated upwards through an iterative algorithm that removes redundant information while merging lower-level summaries. At each level, the system maintains a reference list supporting quadruple IDs and origin links, forming a verifiable audit trail. The module's output is a time-sorted set of summaries reflecting detailed financial conditions and optimized for subsequent retrieval.

[0087] The incremental update module enables efficient graph updates without global reindexing. Upon receiving a new financial document, ingestion and extraction are selectively performed only on the new data. A deterministic graph merging algorithm compares new quadruples with the existing temporal knowledge graph using composite keys (i.e., entity, relation, time). If a match is found, the system updates the value and source; otherwise, a new edge is created. The updated edge triggers a localized refresh of the affected summary via a dependency graph maintained in memory. Update operations are performed transactionally, ensuring atomicity and rollback safety through version control commits similar to those in a distributed database. An embedded change detection classifier based on a lightweight neural network determines whether the semantic content of document fragments is sufficiently novel to warrant graph modification. The module's output is an updated graph and summary repository that remain consistent over time with minimal computational overhead.

[0088] During queries, the system's query module uses a neural semantic parser incorporating symbolic time normalization to interpret natural language questions. A time normalization engine, enhanced with financial-specific rules, transforms ambiguous expressions such as "last quarter," "previous fiscal year," or "after interest rate hikes" into absolute time intervals. The output of this module is a structured query plan, which serves as the retrieval specification for subsequent modules.

[0089] The retrieval module combines symbol filtering and vector similarity search to balance precision and recall. In local retrieval mode, the system queries the temporal knowledge graph for fact edges that match specified entities and relations within a given time interval. The results are scored using a multi-factor ranking function that integrates four components: textual semantic similarity, temporal proximity, model confidence, and source reliability weights. In global retrieval mode, the system accesses pre-computed summaries from a temporal hierarchy graph corresponding to the same time range. A relevance fusion model, implemented as a gradient boosting ranking algorithm, merges local and global scores to select the best subset of evidence fragments. The output of this module is a context package containing detailed evidence facts and a temporal summary, all referenced by entity and timestamp.

[0090] The context assembly module integrates the retrieved evidence into a structured narrative suitable for reasoning within a large language model. A chronological ordering algorithm organizes the facts using timestamps, and a redundancy detector removes duplicate or overlapping information. Each evidence record is converted into a standardized text representation and grouped by entity and time period. The module then constructs a combined prompt according to a dynamic template, including system-level instructions ("ensure accurate chronological order and explicitly cite years and quarters"), the retrieved context, and the user's question. The prompt assembly process uses a token optimization algorithm that dynamically adjusts the length of each context fragment based on its relevance score, keeping it within the maximum context window of the LLM. The module's output is a well-structured, chronologically ordered, ready-to-generate prompt word.

[0091] The generation module executes a large language model to produce the final analytical response. The generation process uses a large, instruction-tuned language model conditional on contextual cues generated by the previous module. This model generates a narrative description that integrates numerical facts and describes temporal evolution. The generated text then enters a validation process that combines rule-based and model validation. A rule-based validator compares each numerical and temporal expression in the output with retrieved evidence to ensure consistency. Simultaneously, a fact consistency classifier, implemented as a lightweight Transformer, flags inconsistencies between the generated statements and the underlying four-tuples. When inconsistencies are detected, the system re-cuestheses the LLM with additional constraints; this process is called regenerative correction. The validated output includes a temporally consistent analytical answer along with a structured metadata block listing the evidence and timestamps used for each statement.

[0092] Furthermore, given the scarcity of complex time-sensitive question-answering datasets, a high-quality dataset is provided, designed to evaluate the time-reasoning capabilities of RAG systems. In one example, the Earnings Call Question Answering (ECT-QA) dataset is derived from earnings call transcripts covering multiple companies and periods, reflecting dynamic factual knowledge within a constantly changing corporate context. It includes both fact-oriented, concrete queries and abstract queries focusing on trends and generalizations. This allows for a comprehensive evaluation of both precise retrieval and deep contextual understanding.

[0093] To simulate incremental knowledge updates in real-world scenarios, the corpus was divided into two distinct parts. In the example, the base corpus includes documents from 2020 to 2023, while the new corpus contains documents from 2024. Queries are categorized as base questions and new questions based on whether the answer requires information from the new corpus. Three evaluation scenarios were conducted to comprehensively assess system performance: evaluating base queries on the base corpus, evaluating base queries on a fully updated corpus, and evaluating new queries on the updated corpus. This comprehensive evaluation framework effectively addresses previously existing blind spots in RAG evaluation, providing insights into the computational update costs and system stability after the update.

[0094] Comprehensive experiments on the ECT-QA dataset demonstrate that TG-RAG significantly outperforms existing RAG baselines across all evaluation settings, showcasing the effectiveness of our method. In particular, when dealing with evolving knowledge, the TG RAG method maintains stable performance on historical queries while achieving excellent results on new queries at an efficient update cost, highlighting its robustness and practicality in dynamic real-world scenarios. Ablation studies and case studies reveal that these benefits stem from our temporal knowledge graph modeling, which utilizes timestamped edges to encode fine-grained facts and delivers precise evidence collection via temporal subgraph retrieval. Furthermore, experimental results on widely used question-answering benchmarks and different LLM backbones confirm the strong generalization ability of the TG-RAG method.

[0095] Retrieval Enhanced Generation (RAG) has been proposed to connect LLMs with external knowledge sources. Specifically, external corpora are segmented, embedded, and stored in a vector database. When a user query arrives, relevant external data is retrieved and combined with the query as input to the LLM, which then generates a fully informed answer. Beyond this baseline framework, various methods have been developed to further optimize the RAG process. However, few methods have yet been applied to the temporal dimension of the data.

[0096] Time is a crucial dimension in our physical world. Numerous facts can evolve relative to time, including those in finance, law, and medicine. Therefore, it is important to consider the time dimension and enable time-based reasoning in existing question-and-answer (QA) models.

[0097] One implementation example teaches QA models to develop time understanding capabilities by training them on synthetic temporal context data and contrastive temporal representation learning on a time-context-based span extraction task. Another implementation example refactors time-sensitive QA into programming, using LLM to translate natural language into executable code that encodes time constraints and selects the answer through program execution. Yet another implementation example addresses time-sensitive QA by leveraging time-aware embeddings and granular contrastive reinforcement learning to enhance the time sensitivity and reasoning capabilities of LLMs. Finally, one implementation example points out that current retrieval systems perform poorly when handling questions requiring temporal reasoning.

[0098] In the example, the corpus D and the time-sensitive query q are used to describe Temporal Graph Retrieval-Enhanced Generation (TG-RAG). The goal is to retrieve relevant evidence from D and generate an answer a. TG-RAG operates in two phases: a two-layer temporal graph indexing phase, which organizes the corpus into a semantically and temporally structured graph, and a dynamic subgraph retrieval and generation phase, where time-relevant facts are retrieved to facilitate response generation. The overall architecture of TG-RAG is as follows: Figure 2 As shown in the image.

[0099] The corpus is organized into a two-layer temporal graph, supporting explicit temporal fact representations and deep time-aware understanding, and allowing for incremental corpus updates. TG-RAG first partitions the original corpus D into multiple blocks C and prompts the LLM to extract temporal quadruples. For each block c∈C, the LLM is required to first identify timestamp nodes, then identify non-temporal entities, and detect the temporal relationships linking those entities. The output is a set of quadruples (v1, v2, e, τ), where v1 and v2 are two entities, e represents a relation, and τ is a normalized timestamp.

[0100] TG-RAG is configured to include a two-layer graph construction. A temporal knowledge graph is constructed based on the extracted temporal quadruples. In the example algorithm, this is constructed using the operation GK=(V, E), where V is the set of non-temporal entities, and E={(v1, v2, e, τ)} is the set of relation edges annotated with timestamps. Multiple facts between the same entity pair at different times are preserved as parallel temporal edges, thus capturing the evolution of their relationships.

[0101] Furthermore, all unique timestamps are organized into a hierarchical time graph GT, which divides the timeline into nested intervals and connects parent intervals to their direct child intervals (e.g., year → quarter → month → day). Cross-layer edges connect each time node in the GT to an edge in the GK that is active at that time, resulting in a two-layer structure that binds factual relations to their time range. Additionally, the TG-RAG system pre-computes and stores vector embeddings based on textual descriptions of entities and relations. In the example algorithm, this can be accomplished by performing ev on each v∈V and ee on each edge in E.

[0102] TG-RAG is configured to include multi-granularity temporal report generation. For each time point in the GT from bottom to top, a report summarizing the activity within its time window is generated. Specifically, TG-RAG aggregates temporal reports of all entities and relationships connected to that time point in the GK, as well as their child nodes, and prompts the LLM to produce concise reports highlighting noteworthy events, interactions, and trends for that time period. These summaries propagate recursively upwards, forming a multi-level reporting hierarchy that progressively provides a broader and richer view of the corpus's temporal dynamics.

[0103] TG-RAG is configured to include incremental updates of time reports, so that when a new document arrives, the time quadruple is extracted and merged into the generated timestamped relation matrix, which is then incorporated into the existing temporal knowledge graph Gk. New time nodes are created in the hierarchical temporal graph Gt only when needed. The system then generates time reports for the newly created leaf time nodes and incrementally updates the reports in Gt along their ancestor paths. Reports for unaffected time nodes remain unchanged. Unlike GraphRAG (Graph Retrieval Enhanced Generation), which requires regenerating all summaries for each date, the TG-RAG method avoids complete recomputation and remains highly efficient.

[0104] like Figure 4 The example code shown represents the local retrieval algorithm of the TG-RAG system. This algorithm receives a user query, a temporal subgraph of the query, relevant time nodes, source document fragments, and the upper limit of the context window. It then scores entities, edges, and text blocks, thus feeding the evidence with the highest temporal relevance to the large language model to generate a response.

[0105] In this algorithm, the system first uses semantic relevance and temporal relevance to identify the subgraph of a specific query, then enables two complementary retrieval modes, and... Figure 4The corresponding local retrieval branch is used to filter fine-grained evidence within the query's time frame. The local retrieval process starts with a time-filtered seed set of entities and executes graph ranking algorithms, such as Personalized PageRank (PPR), on the subgraph of the specific query to calculate the relevance score for each entity.

[0106] The algorithm then scores each relation edge by checking if its timestamp falls within the query's time frame. Edges outside the identified time frame are assigned a value of zero, while edges that meet the time requirement are scored based on the relevance of the entities at both ends. This time metric is a critical decision point because it prevents the retrieval process from selecting semantically similar but temporally irrelevant facts.

[0107] After scoring the edges, the algorithm assigns numerical values ​​to each text block based on the edges extracted from each text block and their semantic relevance to the query. The text blocks are then sorted in descending order of their numerical values, with the highest-ranking text blocks being placed into the available context window whenever possible. The selected context, along with the query, is then provided to the large language model, which generates the final response.

[0108] Referring to Example Algorithm 1, given any query q, TG-RAG identifies a query-specific subgraph through semantic and temporal relevance. Two complementary retrieval modes are then configured. Local retrieval ranks entities and temporally valid edges in the subgraph and scores the blocks they link to, selecting fine-grained evidence within the query's temporal scope. Global retrieval selects significant time nodes and their summaries to provide global context. The selected context is then passed to a generator to produce the final answer.

[0109] TG-RAG includes query-centric time stamps. Given a user query q, the system prompts the LLM to extract each explicit or implicit time expression and determine the complete set of timestamps needed to answer the question. These timestamps are then aligned with corresponding nodes in the hierarchical time graph. This process produces a set of time nodes T. q .

[0110] TG-RAG includes dynamic subgraph localization, where the system computes the query embedding eq and retrieves the top K relation edges from the relation set E, sorted by cosine similarity γε∈=cos(eq,eε) with pre-computed relation embeddings. The retrieved edges define the query-specific subgraph G. q =(V q E q This serves as the basis for subsequent local and global searches. To ensure time relevance, the system further filters timestamps within the query time range T. q The edges within the entity are collected, and the edges of its neighboring entities are collected, thus generating a temporally focused seed set V.q .

[0111] TG-RAG includes local retrieval. The system can be configured to perform retrieval in G... q The personalized PageRank (PPR) algorithm running on time-filtered seed set V q As a personalized vector, each entity v∈V is thus obtained. q The relevance score s(v). For each edge ε=(v1, v2, e, τ)∈E q We assign s(ε)=1[τ∈T] q ](s(v1)+s(v2))). Here, 1[·] represents the indicator function, which returns 1 if the condition is true and 0 otherwise, so τ∈T q Edges in block c receive zero points. Assume E(c) is the initial set of edges extracted from block c, and the system assigns a score to each block c: s(c) = w(c) L ε∈Eq s(ε), where w(c) = IT ε∈E(c) (1+γε), w(c) aggregates the relevance score of the query and all relation edges to capture the overall semantic importance of all relation edges in block c. The system is configured to select blocks in descending order of s(c) until the token count reaches the predefined context window L. ctx To form context C q And it is fed into the LLM along with the query q to generate the final answer a.

[0112] TG-RAG includes a global retrieval process, which can begin by gathering evidence to answer the query. Evidence is formed by (i) blocks with the highest score s(c) as detailed in the local retrieval workflow, and (ii) T q The system generates a time report for each node. Then, the LLM independently processes each piece of evidence to extract a set of atomic points Pe, where each point p∈Pe is a tuple: p=(description, score, confidence). Here, the description is a statement containing key information; the score reflects the point's perceived importance to the query; and the confidence is the LLM's self-evaluation of the point's accuracy. The system then iteratively removes the lowest-confidence points until the input fits within the context window and sorts the points by importance score. Finally, the LLM's task is to synthesize these points into a single structured answer.

[0113] To evaluate time-sensitive QA, the TG-RAG approach can include constructing ECT-QA benchmarks derived from specific and abstract time-related questions from earnings call transcripts. The datasets are constructed using LLM-assisted synthesis and human review to ensure high factual quality. ELT-QA fills a key gap in existing RAG benchmarks by addressing time-sensitive multi-hop and abstract time-related reasoning—a crucial but underexplored dimension in current datasets.

[0114] In a sample implementation of ECT-QA, a question is considered time-sensitive if it contains time qualifiers, such as "in 2023" or "before 2024," and changing these qualifiers alters the correct answer. Two types of time-sensitive questions may be assigned: concrete multi-hop questions and abstract questions. Concrete multi-hop questions are fine-grained, fact-based queries that typically require locating and connecting multiple facts to arrive at an answer. For example, "From Q3 2022 to Q3 2023, in which quarter did Autodesk Inc. experience the highest growth in deferred revenue?" Abstract questions, on the other hand, are query-centric, focusing more on a high-level understanding of the dataset rather than isolated facts. For example, "How can energy companies address cost pressures and improve profitability by 2024?"

[0115] Earnings call transcripts (ECTs) were used as the corpus for our research, chosen for their time-rich nature. These transcripts contain detailed quarterly financial information for each company, and the information is publicly available for publicly traded companies. For example, TG-RAG can be configured to scrape ECTs issued on the Motley Fool platform between 2020 and 2024, retaining companies with transcripts for each quarter during these five years. For each transcript, we only retain the "Preparing to Speak" section, discarding the rest. The final corpus contains 480 ECTs from 24 companies across 5 different sectors, totaling 1.58 million tokens.

[0116] Next, ECT QA can generate a diverse and high-quality temporal multi-hop question-answering dataset with gold-standard evidence using the following workflow. The extraction and alignment of temporal events can be initiated by using the GPT-4o-mini3 prompt to extract temporal events from each file, represented as keyword-timestamp pairs, accompanied by relevant evidence sentences. To align semantically similar but syntactically different keywords, the TG-RAG system can encode them using SentenceTransformer4 and apply HDBSCAN clustering in the example to achieve alignment and cross-file connections for constructing multi-hop questions.

[0117] To construct diverse, specific queries, TG-RAG can categorize question generation based on both time range and reasoning type. Specifically, the system can group 3–8 evidence sentences pointing to the same event entity into three time ranges: single time (within the same point in time), multiple time (spanning multiple time periods), and relative time (before / after a certain point in time). These grouped evidences are then fed into a large language model (such as GPT-4o-mini) to generate enumeration or comparison questions, providing direct and factual answers. Furthermore, the system synthesizes unanswerable questions concerning time periods, entities, or evidence not present in the corpus. This process generates a rich set of time-sensitive questions requiring multi-step reasoning at different levels.

[0118] ECT-QA uses four LLM-evaluation criteria to filter generated questions: reasoning type matching, time specificity, necessity of evidence, and sufficiency of evidence. Answers are verified for factual correctness and regenerated if necessary. Finally, a round of manual review and optimization is performed to ensure the overall quality of the dataset.

[0119] The system can construct abstract questions by simulating potential user profiles and information needs, and generate time-sensitive questions that reflect the true analytical intent.

[0120] In the example, the system can group multiple ECT documents based on shared metadata such as time period, company, or industry. To address input length constraints, the system can first use LLM to generate concise summaries for each document. Given a user role and a corresponding set of document summaries, LLM can be configured to synthesize in-depth questions that user might ask when analyzing the content, with a particular focus on time-related "how" and "why" questions.

[0121] Similar to the process described above, the system can first automatically perform a quality check on each question based on four dimensions: clarity, time basis, depth of analysis, and answerability, using prompts from an LLM (Local Language Management) team. Questions that pass this check will then undergo manual review to ensure quality. Finally, the required number of abstract questions can be built for ECT-QA.

[0122] Figure 3 This visually demonstrates how the TG-RAG method represents and utilizes time information. Figure 3The image shows a visualization of the small subgraphs extracted from the constructed two-layer time graph. The upper layer represents time nodes, while the lower layer displays entities and their associated relationships. A key advantage of this design is that the graph can represent the same factual relationships across different time periods using multiple timestamped edges. For example, the relationship between Digital Corporation (a company) and its revenue can be represented as different time instances in Q1, Q2, and Q3 of 2023.

[0123] This fine-grained temporal modeling effectively captures the evolution of the same knowledge over time, allowing the model to distinguish evidence specific to a particular time, thus avoiding temporal confusion during retrieval and answer generation. For example, for the query "What were Digital Corporation's revenues for each quarter from Q1 to Q3 of 2023?", the TG-RAG model first identifies the time points Q1, Q2, and Q3 of 2023 and retrieves the corresponding company-revenue relationships, resulting in accurate results. Similarly, for the query "What were Digital Corporation's operating cash flow, total liabilities, and earnings per share for Q3 of 2020?", our model first identifies the time point Q3 of 2020 and successfully locates the correct facts. These visualization examples clearly demonstrate that the proposed time graph structure enables effective time-aware retrieval and provides accurate retrieval for time-sensitive questions.

[0124] In practice, the TG-RAG method encodes the same corpus with significantly fewer entities and relations, resulting in lower storage costs and faster retrieval speeds. This compactness stems from TG-RAG's temporal design, which shares entity nodes across different times while introducing timestamped connections to capture evolution, thus effectively eliminating structural redundancy.

[0125] In one example, the system maintains a persistent graph object that includes a time knowledge graph, a hierarchical time graph, cross-layer links, and embeddings, all of which can be stored in a graph database. In the time knowledge graph, entity nodes might represent companies, financial indicators, regulatory agencies, or macroeconomic indicators; edges represent timestamped relationships extracted from the corpus; and patterns are generated from quadruple ontologies. The hierarchical time graph is generated by recursively partitioning time into nested time buckets, allowing for bottom-up and top-down traversal at time resolution through explicit parent-child links. Cross-layer indexes use hash-based functions to map each fact edge to the finest corresponding time node, enabling fast connections between relationships and time nodes during retrieval. The architecture also stores multi-granularity summaries at time nodes, which are concise text reports generated from aggregated relationship and child node summaries.

[0126] The data ingestion process can accept evolving corpora, including company documents, earnings call transcripts, analyst research reports, financial news, and macroeconomic releases, and performs content extraction, standardization, and segmentation into context-preserving chunks. A rule-based parser identifies structural elements such as headings and tables, while a transformer-based model detects the semantic boundaries of text content chunks. The standardized output includes time stamps, embeddings, and source metadata for each segment, preparing structured input for quadruple extraction.

[0127] Time quadruplet extraction is achieved by converting unstructured sentences into canonical tuples of entity-relation-entity or value-normalized timestamp. This process utilizes large language model hints and incorporates symbolic post-processing to ensure consistency. The model can be domain-tuned to eliminate ambiguity in financial terminology and identify numerical representations related to relations and time references. Each quadruplet can be assigned a confidence score, calculated through ensemble consistency across multiple inference runs and redundancy checks across documents, allowing downstream modules to consider the reliability of the extraction.

[0128] The extracted quadruples are assembled into a temporal knowledge graph that preserves parallel edges for relations of the same entity pairs at different times, thus encoding fact evolution without overwriting previous relations. Unique timestamps are organized into a hierarchical temporal graph, with parent-child links reflecting nested calendar intervals, while cross-layer edges bind time nodes to temporally active relations, forming a two-layer graph. The system pre-computes and stores vector embeddings of entities and relations to support semantic similarity ranking during retrieval, in addition to graph structure signals.

[0129] When new documents arrive after the initial indexing, the system selectively processes only the new content, extracts relationships from the new timestamps, and merges them into the existing temporal knowledge graph using composite keys. These composite keys compare entities, relationships, and time attributes to identify updates or insertions. Only when a previously unseen timestamp is encountered will a new time node be created in the temporal hierarchy, and a new summary be generated for the new leaf node, while updates propagate along ancestor paths, leaving unaffected time nodes unchanged.

[0130] During a query, the system analyzes the natural language query to detect explicit and implicit time expressions and converts them into standardized time nodes within a hierarchy, thus establishing the time range for the retrieval. A neural semantic parser generates intermediate representations containing entities, relations, and time constraints, while a time normalization engine maps relative expressions such as "last quarter" to absolute time intervals based on corpus conventions. The parser can also categorize query intent, such as fact-finding, trend comparison, or causal analysis, to guide retrieval and contextual composition.

[0131] The system calculates the query embedding and sorts the relation edges to identify semantically related subgraphs, then filters to retain edges whose timestamps fall within the previously identified time range. Neighboring entities of time-valid edges are collected to form a seed set, which is used for graph-based relevance propagation in subsequent local retrieval.

[0132] Local retrieval can use time-filtered seed entities as personalized vectors to run a customizable ranking algorithm on a query-specific subgraph to compute entity scores reflecting time-related node distances. Each edge receives a score equal to the sum of the scores of its endpoint entities multiplied by a time indicator, which is 1 within the time frame and zero outside the time frame, thus suppressing edges that do not meet the time constraints. Block scores are derived from a combination of edge scores associated with each original block and the semantic similarity between the query and each relation, and the highest-scoring blocks are greedily populated until a predefined context window is reached.

[0133] Global retrieval supplements local evidence with time-node summaries corresponding to the query's time range, and it can also refine both chunks and summaries into atomic information points, characterized by descriptions, importance scores, and confidence values. The iterative process removes the lowest-confidence points until the retained set meets the context window constraint, and then sorts the remaining points by importance for use in synthesis.

[0134] The context assembly module arranges the selected evidence chronologically, removes duplicates or overlaps using a redundancy detector, transforms records into standardized text representations grouped by entity and time period, and then constructs a composite cue that includes system-level instructions, retrieval context, and user query. The token optimization process can adjust the length of each context segment based on relevance scores to stay within the maximum context length of the target large language model.

[0135] The generation module executes a large language model fine-tuned based on assembly prompts, generating a response that includes the numerical and temporal references required by the query and evidence. An optional verification process applies a rule-based check and classifier. The rule-based check compares the numerical and temporal expressions in the generated text with the retrieved evidence, and the classifier flags differences from the underlying quadruples. This can trigger a re-prompt with additional constraints until the inconsistency is resolved.

[0136] The detailed description provided above in conjunction with the accompanying drawings is intended as an example and is not intended to represent the only form that this example can be constructed or used in.

[0137] It should be understood that the configurations and / or methods described herein are exemplary in nature, and the described embodiments, implementations and / or examples should not be considered limiting, as many different variations may exist.

[0138] The specific processes or methods described herein may represent one or more processing strategies. Therefore, the operations illustrated and / or described may be performed in the order shown and / or described, or in other orders, in parallel, or omitted. Similarly, the order of the above processes may also be changed.

[0139] Although the subject matter has been described using language specific to structural features and / or methodological behavior, it should be understood that the subject matter defined in the claims is not necessarily limited to the specific features or behaviors described above. The specific features and behaviors described above are presented only as examples of implementing these claims.

Claims

1. A computer-implemented system for generating enhanced time-map retrieval, comprising: An ingestion module is configured to ingest a document corpus and extract time quadruples from the corpus, each time quadruple including a first entity, a second entity, a relation, and a normalized timestamp; A building module is configured to build a two-layer time graph, which includes a time knowledge layer and a hierarchical time layer. The time knowledge layer has entity nodes annotated with timestamps and relation edges, and the hierarchical time layer arranges timestamps into nested time nodes. The summary module is configured to generate a time summary for each time node in the hierarchical time layer by aggregating the relationships linked to the time nodes; The query module is configured to receive natural language queries and identify a time range, which includes one or more time nodes corresponding to a time map. A retrieval module configured to retrieve a subgraph of the two-layer time graph that is relevant to the query; An assembly module is configured to assemble contextual hints, the contextual hints including evidence obtained from retrieved subgraphs arranged in chronological order; as well as A generation module is configured to use a large language model to generate a response to the natural language query, the large language model being trained by the contextual hints.

2. The system according to claim 1, wherein, Extracting time quadruples involves using domain-specific templates to prompt financial big language models to identify entity, relation, and quantity representations.

3. The system according to claim 1, wherein, The time knowledge layer preserves multiple parallel relationship edges between the same entity pair under different timestamps as different time edges.

4. The system as claimed in claim 1, wherein, The system is configured to perform incremental updates when a new document arrives by selectively extracting time quadruples from the new document, merging the extracted quadruples into the existing time knowledge graph, creating new time nodes in the hierarchical time layer only when encountering previously unseen timestamps, and regenerating summaries for new leaf time nodes and propagating the updated summaries along ancestor paths.

5. The system according to claim 1, wherein, Retrieving the subgraph includes: Calculate query embedding, The relation edges are sorted based on the cosine similarity between the query embedding and the pre-calculated relation embedding. The filtered and sorted edges retain only those whose timestamps fall within the identified time range, and The adjacent entities of time-valid edges are collected to form a seed set, which is used for graph-based correlation propagation.

6. The system according to claim 5, wherein, The retrieval module is configured as follows: Local retrieval is performed by running a personalized sorting algorithm on subgraphs using a seed set as a personalized vector pair. Each edge is scored based on the endpoint entity score multiplied by a time indicator, where the score is one if the edge timestamp is within the time range, and zero otherwise. Block scores are derived from the scores of relevant edges and semantic similarity, and Select the block with the highest score until the token budget is reached.

7. The system according to claim 1, wherein, The generation module is configured to validate the generated response by applying rule-based checks and to use a classifier to label the differences between the generated statement and the underlying quadruple.

8. A computer-implemented method for generating enhanced time-map retrieval, comprising: One or more processors ingest a document corpus and segment the corpus into timestamp-annotated blocks; Extract time quadruples from the block, each time quadruple including a first entity, a second entity, a relation, and a normalized timestamp; Construct a time knowledge graph, which includes entity nodes and relation edges annotated with the timestamps; Construct a hierarchical timeline, which organizes unique timestamps into nested time nodes; Establish cross-layer edges, which connect each time node in the hierarchical time graph to a relation edge in the time knowledge graph, wherein the relation edge is active at the time corresponding to the time node; A time summary for each time node is generated by aggregating link relationships and child node summaries using a large language model; The system receives natural language queries and determines the time range by extracting time representations from the queries and mapping them to corresponding time nodes. The subgraph for a specific query is retrieved by sorting relation edges based on semantic similarity to the query and filtering edges to retain only those within the time range. Assemble context hints from the subgraph of the specific query, the context hints being arranged in chronological order; as well as A large language model trained with the contextual cues is used to generate a response to the query.

9. The method according to claim 8, wherein, Segmenting the corpus involves applying a parser to detect semantic paragraph boundaries.

10. The method according to claim 8, wherein, Extracting time quadruples also includes identifying explicit time references and inferring implicit time anchors from context and metadata.

11. The method of claim 8, further comprising incrementally updating the temporal knowledge graph and the hierarchical temporal graph upon the arrival of a new document by: Extract only the time quadruple from the new document; Use composite bonds to combine the new quaternions into the existing time knowledge graph; Create new time nodes in the hierarchical time map only for timestamps that have not been seen before; Generate a summary of the new leaf time nodes; as well as The summary update is propagated along the hierarchical path.

12. The method according to claim 8, wherein, Retrieving the subgraph also includes: By using time-filtered seed entities as personalized vectors, local retrieval is performed using a sorting algorithm executed on the subgraph. Each relation edge is scored by multiplying the sum of endpoint entity relevance scores by a time indicator function, and... Blocks are selected in descending order of block score until the token budget is reached.

13. The method of claim 8, further comprising: A global search is performed by collecting time node summaries corresponding to the stated time range. Each time-point summary is processed independently using a large language model, and... The timeline summaries are combined into a structured answer.

14. The method of claim 8, further comprising: The generated response is validated by comparing the numerical and temporal representations in the response with retrieved evidence using rule-based validation, and differences are labeled using a classifier. In this process, additional constraints are used to prompt large language models, and detected inconsistencies trigger regeneration and correction.

15. A system comprising: One or more processors; and one or more computer-readable storage media storing instructions, which, when executed by the one or more processors, cause the system to perform a method comprising: Receive document corpus; Extract time quadruples from the corpus. Each quadruple includes a first entity, a second entity, a relation, and a timestamp, which is derived from explicit or implicit time stamps in the corpus. A two-layer time graph is constructed, comprising a time knowledge graph and a hierarchical time graph. The time knowledge graph has entity nodes and relation edges with timestamps, and the hierarchical time graph arranges timestamps into nested intervals. Vector embeddings of stored entities and relationships are used to achieve semantic similarity retrieval; Time summaries of time nodes in the hierarchical time graph are generated by aggregating and linking facts and summaries via a large language model. In response to receiving a natural language query, the system identifies a time range by extracting time representations from the query and mapping them to time nodes, retrieves semantically relevant subgraphs filtered into the time range, performs local retrieval within the time range via graph-based relevance propagation, performs global retrieval by selecting time node summaries corresponding to the time range, assembles chronologically ordered contextual cues from the selected fragments and summaries, and generates a time-consistent answer using a large language model trained on the contextual cues.

16. The system according to claim 15, wherein, The method further includes: Incremental updates are performed by extracting time quadruples only from newly received documents, merging the extracted quadruples into the time knowledge, creating new time nodes only for previously unseen timestamps, and regenerating summaries of affected time nodes by propagation along hierarchical paths.

17. The system according to claim 15, wherein, Performing local retrieval includes: running a personalized ranking algorithm on the subgraph using time-filtered seed entities as personalized vectors, multiplying the sum of endpoint entity scores by the time indicator function t as the score for each edge, and deriving block scores from edge scores.

18. The system of claim 15, wherein, Performing a global retrieval involves independently processing the collected evidence using the large language model to extract atomic points, iteratively removing the points with the lowest confidence, ranking the remaining points by importance score, and synthesizing the ranked points into a structured analytical response.

19. The system according to claim 15, wherein, The method further includes: verifying the generated response through a verification module, which applies rule-based checks to compare the numerical and temporal expressions in the response with retrieved evidence, and applies a classifier to label the differences between the generated statement and the underlying quadruples, and, when a difference is detected, re-evaluates the large language model using additional constraints through a regeneration correction process.

20. The system of claim 15, wherein, Identifying the time range includes: prompting a large language model to extract explicit and implicit time expressions from the query, normalizing the relative time expressions into absolute time intervals using a time normalization engine with financial domain-specific rules, and aligning the normalized intervals to the corresponding time nodes in the hierarchical time graph.

Images