DefaultRAGStrategy

​

Overview

​

Class Definition

from remem.rag_strategies.default_strategy import DefaultRAGStrategy

strategy = DefaultRAGStrategy(remem_instance)

​

Methods

​

index()

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

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

• Calls the original OpenIE indexing logic from ReMem.index_original()
• Extracts triples (subject-predicate-object) from documents
• Creates knowledge graph with phrase and passage nodes
• Builds embeddings for efficient retrieval

documents = [
    "Paris is the capital of France.",
    "The Eiffel Tower is located in Paris.",
    "France is a country in Europe."
]

strategy.index(documents)

​

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,
    to_save: bool = True,
    **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
• to_save (bool): Whether to save retrieval and QA results (default: True)
• **kwargs: Additional parameters

• Tuple containing:
  1. List[QuerySolution]: Query solutions with retrieved documents and answers
  2. List[str]: Response messages from the QA model
  3. List[Dict]: Metadata for each response
  4. Dict: Retrieval metrics (e.g., retrieval recall)
  5. Dict: QA metrics (e.g., exact match, F1 score)

1. Retrieves relevant documents using graph-based retrieval
2. Evaluates retrieval performance if gold documents provided
3. Performs question-answering using retrieved context
4. Evaluates QA performance if gold answers provided
5. Saves results if to_save=True

queries = [
    "What is the capital of France?",
    "Where is the Eiffel Tower located?"
]

gold_answers = [
    ["Paris"],
    ["Paris"]
]

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

print(f"Exact Match: {qa_metrics['qa_em']:.2f}")
print(f"F1 Score: {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 (e.g., "passage", "triple")

• Retrieved documents and their similarity scores

• Uses the default retrieve_each_query_original implementation
• Leverages graph-based retrieval with embeddings
• Returns passages or triples based on return_chunk parameter

query = "What is the capital of France?"
docs, scores = strategy.retrieve_each_query(query, return_chunk="passage")

for i, (doc, score) in enumerate(zip(docs, scores)):
    print(f"{i+1}. [Score: {score:.3f}] {doc}")

​

Use Cases

• Structured Knowledge Extraction: When you need to extract factual triples from documents
• General-Purpose QA: Standard question-answering over document collections
• Knowledge Graph Construction: Building knowledge graphs from unstructured text
• Fact Verification: Retrieving supporting evidence for claims

​

Configuration

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

remem = ReMem(
    extract_method="openie",  # Use OpenIE extraction
    embedding_model="text-embedding-ada-002",
    qa_model="gpt-4"
)

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