Temporal Graph RAG

The core data model represents facts as temporal triples or quadruples (subject, predicate, object, timestamp). This allows the system to store and retrieve not just what is true, but when it was true. For example:

• (CompanyA, acquires, CompanyB, 2022-03-15)
• (Employee123, holds_position, 'CTO', [2020-01-01, 2023-12-31]) Retrieval queries can then be scoped to specific time windows or sequences, providing the language model with chronologically precise context.

The system retrieves connected sequences of events or state changes, enabling multi-step temporal reasoning. Instead of retrieving isolated facts, it fetches temporal subgraphs that show causality and progression.

Key capabilities:

• Answering "how did" questions: Retrieve the step-by-step events leading to an outcome.
• Handling state changes: Track the evolution of an entity's attributes over time (e.g., price history, role changes).
• Temporal filtering: Execute queries like "What happened between Q1 and Q3?" or "What was the status before event X?" This moves beyond static fact lookup to narrative understanding.

Every generated statement about the past is explicitly linked to time-stamped source facts within the graph. This provides auditable provenance and eliminates ambiguity about which period a fact references.

Mechanisms include:

• Source node tracing with timestamps: The system records the specific temporal nodes and edges used for generation.
• Temporal consistency checks: Generated timelines are automatically validated against the graph's chronological constraints to flag anachronisms.
• Explicit time references in prompts: Retrieved context is formatted with clear temporal markers (e.g., "As of 2021-06-30, the revenue was..."). This is critical for financial, legal, and operational reporting where the timing of information is as important as the information itself.

Natural language queries often have implicit or ambiguous time references (e.g., "previous quarter," "last year," "currently"). Temporal Graph RAG resolves this through context-aware temporal resolution.

The process involves:

1. Temporal expression recognition: Identifying phrases like "last month" or "Q3" in the query.
2. Reference time resolution: Determining the anchor date (often the query execution date or a date provided in conversation history).
3. Time window calculation: Translating the ambiguous phrase into a concrete [start_time, end_time] interval for graph querying. This ensures the system retrieves facts relevant to the user's intended timeframe, not just the most recent data.

The architecture supports querying and reasoning over sophisticated temporal relationships defined in ontologies, such as Allen's Interval Algebra.

It can retrieve facts based on patterns like:

• Before/After: Events preceding or following a reference point.
• During: States that were true throughout a given interval.
• Overlaps: Events that coincided partially in time.
• Meets: One event ending exactly when another begins. This allows for answering complex questions like "Which projects were active during the merger negotiations?" or "Did the policy change before or after the incident?" by performing structured temporal joins within the graph.

Temporal Graph RAG bridges discrete events in the graph with continuous time-series data. Numerical metrics (e.g., daily sales, sensor readings) are linked as time-varying attributes of graph entities.

This enables:

• Explanatory retrieval: Retrieve the event (e.g., a marketing campaign) that corresponds to a spike in a time-series metric.
• Conditional querying: Answer questions like "What was the average server load during the system outage?" by joining the outage event node with the related metric stream.
• Trend summarization: Generate narratives that explain trends by correlating sequences of business events with quantitative changes. This creates a unified view for analyzing both what happened and how metrics changed.

A knowledge graph where facts (edges) are annotated with temporal validity intervals or timestamps. This enables the representation of time-varying entity states and event sequences. Core structures include:

• 4D triples: (subject, predicate, object, [start_time, end_time])
• Event-centric models: Nodes represent events linked to participating entities.
• Versioned entities: Snapshots of an entity node at different points in time. This structured representation is the primary retrieval source for Temporal Graph RAG, allowing queries like "What was the company's revenue in Q3 2023?"

A natural language or formal query that explicitly or implicitly references a temporal dimension. In Temporal Graph RAG, these queries trigger retrieval of facts valid at a specific time or over a period. Examples include:

• Point-in-time: "Who was the CEO in 2019?"
• Interval-based: "Which products were launched between 2020 and 2022?"
• Sequential: "List the merger events for Company X in chronological order."
• Trend-based: "Show the stock price trend over the last 5 years." The system must parse the temporal intent and map it to the graph's time indices.

The logical process of drawing inferences based on time-ordered facts. In a Temporal Graph RAG context, this can occur both during retrieval (graph traversal) and within the LLM's generation phase. Key capabilities include:

• Temporal Consistency Checking: Ensuring generated narratives don't contain anachronisms (e.g., citing a policy that didn't exist at the queried time).
• Sequence Understanding: Inferring causality or correlation from event ordering (e.g., a product launch followed by a sales increase).
• Interval Algebra: Reasoning about relationships between time intervals (e.g., before, during, overlaps). This moves the system beyond static fact lookup to dynamic narrative construction.

The process of extracting a connected, relevant subgraph from the larger temporal knowledge graph in response to a query. For temporal queries, this subgraph must include the relevant time-constrained edges. The process involves:

• Temporal Filtering: Pruning edges outside the queried validity window.
• Path Traversal: Following relationships that connect entities across the specified time period.
• Context Preservation: Retrieving not just the direct answer but the local network of contemporaneous facts to provide context for the LLM (e.g., retrieving a CEO node and the company's financials from the same period).

A retrieval technique that combines semantic similarity search over vector embeddings with structured, time-aware pattern matching over the graph. This is critical for Temporal Graph RAG to handle ambiguous queries. For example:

1. A vector search finds textually similar nodes for "market downturn."
2. The graph engine filters these nodes to those active during the 2008 financial crisis timeframe.
3. It then traverses relationships to retrieve affected companies and their quarterly results. This hybrid approach ensures both semantic relevance and temporal precision.

The principle of explicitly linking every generated claim to a verifiable source fact within the knowledge graph. In a temporal context, this includes source time tracing. The system must provide provenance not just for what fact, but when it was true. This is achieved through:

• Annotated Prompts: Injecting retrieved triples with their timestamps into the LLM context.
• Source Attribution: Outputting citations that include entity IDs and temporal validity intervals.
• Consistency Verification: Cross-checking generated timelines against the source graph's event ordering. This is the core mechanism for auditability and trust in Temporal Graph RAG outputs.