RAGStrategy Base Class

​

Overview

​

RAGStrategy Base Class

​

Constructor

class RAGStrategy(ABC):
    def __init__(self, remem_instance)

• remem_instance: The ReMem instance to use for this strategy

​

Abstract Methods

​

index()

@abstractmethod
def index(self, docs: List[str]) -> None

• docs (List[str]): List of documents to index

​

rag_for_qa()

@abstractmethod
def rag_for_qa(
    self,
    queries: Union[List[str], List[QuerySolution]],
    num_to_retrieve: int = 10,
    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: 10)
• gold_answers (optional): Gold standard answers for evaluation
• gold_docs (optional): Gold standard documents for evaluation
• metrics (tuple): Evaluation metrics to compute (default: ("qa_em", "qa_f1", "retrieval_recall"))
• question_metadata (optional): Additional metadata for questions
• **kwargs: Strategy-specific parameters

• Tuple containing:
  1. List[QuerySolution]: Query solutions with retrieved documents and answers
  2. List[str]: Response messages
  3. List[Dict]: Metadata for each response
  4. Dict: Retrieval metrics
  5. Dict: QA metrics

​

Instance Methods

​

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

• Retrieved documents and scores

​

get_graph_info()

def get_graph_info(self) -> Dict

• Dictionary containing:
  • num_phrase_nodes: Number of unique phrase nodes
  • num_passage_nodes: Number of unique passage nodes
  • num_total_nodes: Total number of nodes
  • num_extracted_triples: Number of unique extracted triples
  • num_triples_with_passage_node: Number of triples involving at least one passage node
  • num_synonymy_triples: Number of synonymy triples
  • num_total_triples: Total number of triples

​

RAGStrategyFactory

​

Class Methods

​

create_strategy()

@classmethod
def create_strategy(
    cls,
    extract_method: str,
    remem_instance
) -> RAGStrategy

• extract_method (str): The extraction method name ("openie", "episodic_gist", or "temporal")
• remem_instance: The ReMem instance

• RAGStrategy: The appropriate strategy instance

• ValueError: If the extraction method is not supported

from remem.rag_strategies.factory import RAGStrategyFactory

# Create a strategy for episodic gist extraction
strategy = RAGStrategyFactory.create_strategy("episodic_gist", remem_instance)

# Index documents
strategy.index(documents)

# Run QA
results = strategy.rag_for_qa(queries)

​

register_strategy()

@classmethod
def register_strategy(
    cls,
    extract_method: str,
    strategy_class: Type[RAGStrategy]
)

• extract_method (str): The extraction method name
• strategy_class: The strategy class to register

​

get_supported_methods()

@classmethod
def get_supported_methods(cls) -> list[str]

• List of supported extraction method names

methods = RAGStrategyFactory.get_supported_methods()
print(methods)  # ['openie', 'episodic_gist', 'temporal']