LightMem/src/lightmem/memory_toolkits/memory_search.py

import argparse
import json
from concurrent.futures import ThreadPoolExecutor, as_completed
from tqdm import tqdm
import threading
from copy import deepcopy
from memories import (
    CONFIG_MAPPING,
    MEMORY_LAYERS_MAPPING,
    DATASET_MAPPING,
)
from memories.datasets.base import QuestionAnswerPair, MemoryDataset
from typing import (
    Dict,
    Any,
    Optional,
    List,
)

_LOCK = threading.Lock()


def memory_search(
    layer_type: str,
    user_id: str,
    questions: List[QuestionAnswerPair],
    config: Optional[Dict[str, Any]] = None,
    top_k: int = 10,
    strict: bool = True, 
    dataset: Optional[MemoryDataset] = None,
) -> List[Dict[str, Any]]:
    """Search memories for a given user based on questions."""
    config = config or {}
    llm_model = config["llm_model"]
    config["user_id"] = user_id
    config["save_dir"] = f"{layer_type}_{llm_model}/{user_id}"
    
    # Load memory layer configuration and class using lazy mapping
    config_cls = CONFIG_MAPPING[layer_type]
    config = config_cls(**config)
    
    with _LOCK:
        layer_cls = MEMORY_LAYERS_MAPPING[layer_type]
        layer = layer_cls(config)
    
    # Load the pre-built memory
    with _LOCK:
        if not layer.load_memory(user_id):
            msg = f"No memory found for user {user_id}."
            if strict:
                raise ValueError(msg)
            else:
                # For some baselines, there are a few cases 
                # these baselines cannot process without throwing an error.
                # We simply return an empty memory for these cases.
                print(msg)
                return [
                    {
                        "retrieved_memories": [
                            {
                                "used_content": "[NO RETRIEVED MEMORIES]"
                            }
                        ],
                        "qa_pair": qa_pair,
                    }
                    for qa_pair in questions 
                ]
    
    # Perform retrieval for each question
    original_count = len(questions)
    questions = dataset.filter_questions(questions)
    questions = list(questions)
    total_q = len(questions)
    print(f"[INFO] {user_id}: {total_q} questions to search.")

    retrievals = []
    pbar = tqdm(
        questions,
        total=total_q,
        desc=f"{user_id}",
        leave=False,       # Avoid too many 100% progress remnants under nohup
    )

    for qa_pair in pbar:
        query = qa_pair.question
        # Perform retrieval using the unified interface
        retrieved_memories = layer.retrieve(query, k=top_k)
        # MemZeroGraph return a dict with "memories" and "relations"
        retrieval_result = {
            "retrieved_memories": retrieved_memories,
            "qa_pair": qa_pair,
            "user_id": user_id, 
        }
        retrievals.append(retrieval_result)
    
    return retrievals


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="A script to search memories for a given user based on questions."
    )
    parser.add_argument(
        "--memory-type",
        choices=list(MEMORY_LAYERS_MAPPING.keys()),
        type=str,
        required=True,
        help="The type of the memory layer to be searched."
    )
    parser.add_argument(
        "--dataset-type",
        choices=list(DATASET_MAPPING.keys()),
        type=str,
        required=True,
        help="The type of the dataset used to search the memory layer."
    )
    parser.add_argument(
        "--dataset-path",
        type=str,
        required=True,
        help="The path to the dataset."
    )
    parser.add_argument(
        "--num-workers",
        type=int,
        default=4,
        help="The number of threads to use for the search."
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=42,
        help="Random seed used to sample the dataset if the user provides the sample size."
    )
    parser.add_argument(
        "--sample-size",
        type=int,
        default=None,
        help="Subset size from dataset."
    )
    parser.add_argument(
        "--config-path",
        type=str,
        default=None,
        help="Path to JSON config for memory method."
    )
    parser.add_argument(
        "--top-k",
        type=int,
        default=10,
        help="Number of memories to retrieve for each query."
    )
    parser.add_argument(
        "--start-idx",
        type=int,
        default=None,
        help="The starting index of the trajectories to be processed."
    )
    parser.add_argument(
        "--end-idx",
        type=int,
        default=None,
        help="The ending index of the trajectories to be processed."
    )
    parser.add_argument(
        "--strict",
        action="store_true",
        help="Whether to raise an error if no memory is found for a user."
    )
    args = parser.parse_args()
    
    # Prepare the dataset using lazy mapping
    ds_cls = DATASET_MAPPING[args.dataset_type]
    dataset = ds_cls.read_raw_data(args.dataset_path)
    if args.sample_size is not None:
        dataset = dataset.sample(size=args.sample_size, seed=args.seed)
    print("The dataset is loaded successfully.")
    
    # Load configuration
    config = None
    if args.config_path is not None:
        with open(args.config_path, 'r', encoding="utf-8") as f:
            config = json.load(f)
    
    llm_model = config["llm_model"]
    # Process index range
    if args.start_idx is None:
        args.start_idx = 0
    if args.end_idx is None:
        args.end_idx = len(dataset)
    args.start_idx, args.end_idx = max(0, args.start_idx), min(args.end_idx, len(dataset))
    if args.start_idx >= args.end_idx:
        raise ValueError("The starting index must be less than the ending index.")
    
    # Perform memory 
    print("Searching memories for each trajectory...")
    retrievals = []
    with ThreadPoolExecutor(max_workers=args.num_workers) as executor:
        futures = []
        for trajectory, qa_pairs in zip(*dataset[args.start_idx: args.end_idx]):
            user_id = f"user_{dataset.__class__.__name__}_{trajectory.metadata['id']}"
            future = executor.submit(
                memory_search,
                args.memory_type,
                user_id,
                qa_pairs,
                config=deepcopy(config),
                top_k=args.top_k,
                strict=args.strict,
                dataset=dataset,
            )
            futures.append(future)
        for future in tqdm(
            as_completed(futures), total=len(futures), desc="Searching memories"
        ):
            results = future.result()
            retrievals.extend(results)

    for item in retrievals:
        item["qa_pair"] = item["qa_pair"].model_dump()
    output_path = f"{args.memory_type}_{llm_model}_{args.dataset_type}_{args.top_k}_{args.start_idx}_{args.end_idx}.json"

    with open(output_path, 'w', encoding="utf-8") as f:
        json.dump(
            retrievals, 
            f, 
            ensure_ascii=False, 
            indent=4,
        )
    print(f"Saved {len(retrievals)} results to {output_path}.")