Skip to main content

​
Overview

The TemporalStrategy is designed for temporal knowledge extraction and retrieval, where facts include time qualifiers. It’s ideal for time-sensitive information, historical data, and event-based applications.

​
Class Definition

from remem.rag_strategies.temporal_strategy import TemporalStrategy

strategy = TemporalStrategy(remem_instance)

​
Methods

​
index()

Index documents using temporal extraction with time-qualified facts. 
def index(self, docs: List) -> None
Parameters:
  • docs (List): List of documents to index
Returns: None Behavior:
  1. Temporal Extraction: Extracts facts with temporal qualifiers:
    • Subject-predicate-object triples
    • Time qualifiers (dates, time periods, temporal expressions)
    • Additional qualifiers (location, context, etc.)
  2. Graph Construction: Builds a temporal knowledge graph:
    • Verbatim nodes (original text)
    • Fact nodes (temporal facts with qualifiers)
    • Entity nodes (subjects and objects)
    • Time entity nodes (temporal expressions)
  3. Incremental Updates: Only processes new documents if existing components exist
Example: 
documents = [
    "In 2019, Paris hosted the FIFA Women's World Cup.",
    "The Eiffel Tower was completed in 1889.",
    "France joined the European Union in 1957."
]

strategy.index(documents)
Extracted Temporal Facts: 
# Example fact structure:
{
    "subject": "Paris",
    "predicate": "hosted",
    "object": "FIFA Women's World Cup",
    "qualifiers": {
        "time": "2019"
    }
}

​
rag_for_qa()

Run question-answering evaluation using agent-based retrieval for temporal data. 
def rag_for_qa(
    self,
    queries: Union[List[str], List[QuerySolution]],
    num_to_retrieve: int = 5,
    gold_answers: Optional[List[List[str]]] = None,
    gold_docs: Optional[List[List[str]]] = None,
    metrics: Tuple[str, ...] = ("qa_em", "qa_f1", "retrieval_recall"),
    question_metadata: Optional[List[Dict]] = None,
    **kwargs,
) -> Tuple[List[QuerySolution], List[str], List[Dict], Dict, Dict]
Parameters:
  • queries: Input queries (strings or QuerySolution objects)
  • num_to_retrieve (int): Number of documents to retrieve per query (default: 5)
  • gold_answers (optional): Gold standard answers for evaluation
  • gold_docs (optional): Gold standard documents for evaluation
  • metrics (tuple): Evaluation metrics to compute
  • question_metadata (optional): Additional metadata for questions
  • **kwargs: Additional parameters
Returns:
  • Tuple containing:
    1. List[QuerySolution]: Query solutions with retrieved documents and answers
    2. List[str]: Response messages
    3. List[Dict]: Metadata
    4. Dict: Retrieval metrics
    5. Dict: QA metrics
Behavior:
  1. Uses agent-based retrieval with temporal reasoning
  2. Traverses the temporal knowledge graph
  3. Considers time qualifiers in retrieval and ranking
  4. Returns verbatim content by default
Example: 
queries = [
    "When did Paris host the FIFA Women's World Cup?",
    "What year was the Eiffel Tower completed?",
    "When did France join the EU?"
]

gold_answers = [
    ["2019"],
    ["1889"],
    ["1957"]
]

query_solutions, responses, metadata, retrieval_metrics, qa_metrics = strategy.rag_for_qa(
    queries=queries,
    num_to_retrieve=5,
    gold_answers=gold_answers,
    metrics=("qa_em", "qa_f1", "retrieval_recall")
)

print(f"Exact Match: {qa_metrics['qa_em']:.2f}")
print(f"Retrieval Recall: {retrieval_metrics['retrieval_recall']:.2f}")

​
retrieve_each_query()

Retrieve documents for a single query using temporal graph traversal. 
def retrieve_each_query(
    self,
    query: str,
    return_chunk: Optional[str] = None
)
Parameters:
  • query (str): Input query
  • return_chunk (optional): Type of chunk to return ("verbatim" or "facts")
Returns:
  • Retrieved chunk IDs, similarity scores, and agent result
Behavior:
  • Uses GraphAgent for multi-turn reasoning over temporal graph
  • Considers temporal relationships in retrieval
  • Can return verbatim content or temporal facts
Example: 
query = "What happened in Paris in 2019?"
chunk_ids, scores, agent_result = strategy.retrieve_each_query(
    query,
    return_chunk="verbatim"
)

print(f"Retrieved {len(chunk_ids)} relevant chunks")

​
Temporal Graph Structure

The temporal strategy creates a graph with temporal relationships: 
┌─────────────┐
│  Verbatim   │  (Original text)
│   Nodes     │
└──────┬──────┘
       │
       v
┌─────────────┐
│ Temporal    │  (Facts with time qualifiers)
│   Facts     │
└──────┬──────┘
       │
       ├──────> Entity Nodes (subjects, objects)
       │
       └──────> Time Entity Nodes (temporal expressions)
Edge Types:
  • Verbatim → Fact: “contains_fact”
  • Fact → Entity: Extracted from subject/object
  • Fact → Time Entity: Temporal qualifiers
  • Entity → Entity: Relationships from facts

​
Use Cases

The TemporalStrategy is ideal for:
  • Historical QA: Answering questions about historical events
  • Time-Sensitive Information: Retrieving facts valid at specific times
  • Event Timelines: Building and querying event sequences
  • Temporal Reasoning: Understanding when events occurred relative to each other
  • Change Tracking: Tracking how facts change over time
Example Applications:
  • Historical knowledge bases
  • News article archives
  • Scientific literature with publication dates
  • Legal documents with effective dates
  • Medical records with timestamps

​
Configuration Example

from remem import ReMem
from remem.rag_strategies.factory import RAGStrategyFactory

remem = ReMem(
    extract_method="temporal",
    embedding_model="text-embedding-ada-002",
    qa_model="gpt-4",
    save_openie=True,
    add_synonymy_edges=True  # Optional: add similarity edges
)

strategy = RAGStrategyFactory.create_strategy("temporal", remem)

# Index temporal documents
strategy.index(historical_documents)

# Query with temporal reasoning
results = strategy.rag_for_qa(
    queries=["What events happened in 2019?"],
    num_to_retrieve=10
)

​
Helper Methods

​
_get_graph_info()

Get information about the temporal graph structure. 
def _get_graph_info(self) -> Dict
Returns:
  • Dictionary containing:
    • num_verbatim_nodes: Number of verbatim nodes
    • num_entity_nodes: Number of entity nodes
    • num_temporal_fact_nodes: Number of temporal fact nodes
    • num_total_nodes: Total number of nodes
    • num_edges: Total number of edges
    • igraph_vertex_count: Number of vertices in the graph
Example: 
info = strategy._get_graph_info()
print(f"Total nodes: {info['num_total_nodes']}")
print(f"Temporal facts: {info['num_temporal_fact_nodes']}")

Build docs developers (and LLMs) love

Get started for freeTalk to us