TemporalStrategy

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/intuit-ai-research/REMem/llms.txt

Use this file to discover all available pages before exploring further.

​

Overview

​

Class Definition

from remem.rag_strategies.temporal_strategy import TemporalStrategy

strategy = TemporalStrategy(remem_instance)

​

Methods

​

index()

def index(self, docs: List) -> None

• docs (List): List of documents to index

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

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)

# Example fact structure:
{
    "subject": "Paris",
    "predicate": "hosted",
    "object": "FIFA Women's World Cup",
    "qualifiers": {
        "time": "2019"
    }
}

​

rag_for_qa()

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]

• 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

• 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

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

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()

def retrieve_each_query(
    self,
    query: str,
    return_chunk: Optional[str] = None
)

• query (str): Input query
• return_chunk (optional): Type of chunk to return ("verbatim" or "facts")

• Retrieved chunk IDs, similarity scores, and agent result

• Uses GraphAgent for multi-turn reasoning over temporal graph
• Considers temporal relationships in retrieval
• Can return verbatim content or temporal facts

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

┌─────────────┐
│  Verbatim   │  (Original text)
│   Nodes     │
└──────┬──────┘
       │
       v
┌─────────────┐
│ Temporal    │  (Facts with time qualifiers)
│   Facts     │
└──────┬──────┘
       │
       ├──────> Entity Nodes (subjects, objects)
       │
       └──────> Time Entity Nodes (temporal expressions)

• Verbatim → Fact: “contains_fact”
• Fact → Entity: Extracted from subject/object
• Fact → Time Entity: Temporal qualifiers
• Entity → Entity: Relationships from facts

​

Use Cases

• 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

• 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()

def _get_graph_info(self) -> Dict

• 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

info = strategy._get_graph_info()
print(f"Total nodes: {info['num_total_nodes']}")
print(f"Temporal facts: {info['num_temporal_fact_nodes']}")