EpisodicGistStrategy

​

Overview

​

Class Definition

from remem.rag_strategies.episodic_gist_strategy import EpisodicGistStrategy

strategy = EpisodicGistStrategy(remem_instance)

​

Constructor

def __init__(self, remem_instance)

• concatenate_gists_per_chunk: Whether to concatenate all gists per chunk into a single node
• split_verbatim_per_chunk: Whether to split verbatim content into separate nodes per message

​

Methods

​

index()

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

• docs (List): List of documents to index (can be strings or structured conversation data)

1. Extraction: Extracts multiple representations from each document:
   • Verbatim: Original text content
   • Gists: Concise summaries of the content
   • Facts: Structured facts with subject-predicate-object-qualifiers
   • Entities: Key entities mentioned in the facts
2. Graph Construction: Builds a multi-level knowledge graph:
   • Verbatim nodes connect to gist nodes
   • Gist nodes connect to fact nodes
   • Fact nodes connect entities
   • Synonymy edges connect similar gists
3. Incremental Updates: Only processes new documents if existing graph exists

# For conversational data
conversations = [
    [
        {"role": "user", "content": "What's the capital of France?"},
        {"role": "assistant", "content": "The capital of France is Paris."}
    ],
    [
        {"role": "user", "content": "Tell me about the Eiffel Tower."},
        {"role": "assistant", "content": "The Eiffel Tower is a famous landmark in Paris."}
    ]
]

strategy.index(conversations)

remem = ReMem(
    extract_method="episodic_gist",
    concatenate_gists_per_chunk=True,  # Combine all gists per chunk
    split_verbatim_per_chunk=True,     # Split verbatim by messages
)

​

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,
    parallel: bool = True,
    max_workers: int = 8,
    return_chunk: str = "gists",
    evaluate_per_sample: bool = False,
    save_per_sample: bool = False,
    force_rag: bool = False,
    inference_type: str = "default",
    **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
• parallel (bool): Whether to process queries in parallel (default: True)
• max_workers (int): Number of parallel workers (default: 8)
• return_chunk (str): Type of chunk to return - "verbatim" or "gists" (default: "gists")
• evaluate_per_sample (bool): Evaluate metrics for each sample immediately (default: False)
• save_per_sample (bool): Save each sample result individually (default: False)
• force_rag (bool): Force recomputation even if saved results exist (default: False)
• inference_type (str): Identifier for inference type, used in filenames (default: "default")
• **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. Parallel Processing: Processes multiple queries concurrently for better performance
2. Per-Sample Evaluation: Computes metrics during processing for real-time feedback
3. Caching: Saves individual results and can load cached results to skip recomputation
4. Multi-Level Retrieval: Can return either verbatim content or gist summaries

queries = [
    "What did the user ask about France?",
    "What information was provided about Paris?"
]

gold_answers = [
    ["capital of France"],
    ["Eiffel Tower location"]
]

# With parallel processing and per-sample evaluation
query_solutions, responses, metadata, retrieval_metrics, qa_metrics = strategy.rag_for_qa(
    queries=queries,
    num_to_retrieve=10,
    gold_answers=gold_answers,
    parallel=True,
    max_workers=4,
    return_chunk="gists",  # Return gist summaries
    evaluate_per_sample=True,  # Show progress during evaluation
    save_per_sample=True,  # Cache results
    inference_type="episodic_eval"
)

print(f"Overall F1: {qa_metrics['qa_f1']:.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 "gists")

• Retrieved chunk IDs, similarity scores, and agent result

• Uses graph-based retrieval with multi-hop reasoning
• Can return either verbatim content or gist summaries
• Leverages agent-based exploration of the episodic graph

​

Graph Structure

┌─────────────┐
│  Verbatim   │  (Original conversation turns)
│   Nodes     │
└──────┬──────┘
       │
       v
┌─────────────┐
│    Gist     │  (Concise summaries)
│   Nodes     │
└──────┬──────┘
       │
       v
┌─────────────┐
│    Fact     │  (Structured facts with qualifiers)
│   Nodes     │
└──────┬──────┘
       │
       v
┌─────────────┐
│   Entity    │  (Extracted entities)
│   Nodes     │
└─────────────┘

• Synonymy edges: Connect similar gist nodes
• Entity relationships: Connect related entities within facts

​

Use Cases

• Conversational AI: Maintaining context across multi-turn conversations
• Session-Based Retrieval: Retrieving relevant past interactions
• Multi-Level Understanding: Querying at different levels of abstraction (verbatim vs. gist)
• Long-Term Memory: Building episodic memory for AI assistants
• Conversation Analysis: Understanding patterns and facts from chat histories

​

Configuration Example

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

remem = ReMem(
    extract_method="episodic_gist",
    embedding_model="text-embedding-ada-002",
    qa_model="gpt-4",
    concatenate_gists_per_chunk=True,
    split_verbatim_per_chunk=True,
    save_openie=True
)

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