misc / LightMem /src /lightmem /memory_toolkits /memory_construction.py

Upload LightMem project snapshot

5e028bf verified 7 months ago

20.9 kB

import argparse
import json
from concurrent.futures import ThreadPoolExecutor, as_completed
from datetime import datetime
from tqdm import tqdm
import time 
import threading
from importlib.util import find_spec
from copy import deepcopy 
import os
from contextlib import nullcontext

from token_monitor import (
    CostStateManager, 
    token_monitor, 
    CostState, 
    get_tokenizer_for_model,
)
from monkey_patch import (
    PatchSpec, 
    MonkeyPatcher, 
    make_attr_patch, 
)

from memories import (
    CONFIG_MAPPING,
    MEMORY_LAYERS_MAPPING,
    DATASET_MAPPING,
)
from memories.datasets.base import Trajectory
from typing import (
    Dict, 
    Any, 
    Optional, 
    Tuple, 
    List, 
    Callable,
)
from memories.datasets.base import Trajectory, Message, QuestionAnswerPair, Session
from importlib import import_module

_LOCK = threading.Lock()

def _check_langchain_core_imports() -> None: 
    """Check if `langchain_core` is installed."""
    if find_spec("langchain_core") is None:
        raise ImportError("`langchain_core` is not installed. Please install it to use this function.")

def _normalize_langmem_messages(*args, **kwargs) -> Dict[str, List[Dict[str, str]] | str | float | int]:
    """A helper function to process the messages of LangMem."""
    _check_langchain_core_imports() 
    from langchain_core.messages import (
        HumanMessage, 
        SystemMessage, 
        AIMessage, 
        ToolMessage, 
    )

    messages = kwargs.get("messages", args[0])
    assert len(messages) == 1, "Unconsidered Case."
    messages = messages[0]
    normalized_messages = []
    for message in messages:
        if isinstance(message, SystemMessage):
            normalized_messages.append(
                {
                    "role": "system", 
                    "content": message.content
                }
            )
        elif isinstance(message, HumanMessage):
            normalized_messages.append(
                {
                    "role": "user", 
                    "content": message.content
                }
            ) 
        elif isinstance(message, AIMessage):
            if message.content is not None and not isinstance(message.content, str):
                raise ValueError(
                    f"The content of the message is not a string: {type(message.content)}."
                )
            normalized_messages.append(
                {
                    "role": "assistant", 
                    "content": message.content,
                    "tool_calls": [
                        {
                            "id": tool_call["id"], 
                            "type": "function", 
                            "function": {
                                "name": tool_call["name"],
                                "arguments": str(tool_call["args"]),
                            }
                        }
                        for tool_call in message.tool_calls
                    ], 
                }
            )
        elif isinstance(message, ToolMessage):
            # See https://platform.openai.com/docs/guides/function-calling 
            normalized_messages.append(
                {
                    "role": "tool", 
                    "tool_call_id": message.tool_call_id,
                    "content": message.content,
                }
            )
        else:
            raise ValueError(f"Unsupported message type: {type(message)}.")
    
    return normalized_messages

def _extract_langmem_model(
    llm_model: str, 
    query_model: Optional[str], 
    *args,  
    **kwargs
) -> Tuple[str, Dict[str, Any]]:
    """A helper function to extract the model name and metadata for LangMem."""
    _check_langchain_core_imports()  
    from langchain_core.messages import HumanMessage

    llm_model = llm_model.split(':', 1)[1]
    query_model = query_model.split(':', 1)[1] if query_model is not None else None 

    messages = kwargs.get("messages", args[0])
    assert len(messages) == 1, "Unconsidered Case."
    messages = messages[0]
    # The following parameters are used in LiteLLM's token counter. 
    metadata = {
        "tools": kwargs.get("tools"), 
        "tool_choice": kwargs.get("tool_choice"), 
    } 
    if isinstance(messages[0], HumanMessage) and messages[0].content.startswith(
        "Use parallel tool calling to search for distinct memories relevant to this conversation."
    ):
        if query_model is None:
            raise ValueError("Query model is not provided.")
        return query_model, metadata 
    return llm_model, metadata 

def _extract_langmem_output(response) -> Dict[str, List[Dict[str, str]] | str | float | int]:
    """A helper function to extract the output for LangMem."""
    assert len(response.generations) == 1, "Unconsidered Case."
    assert len(response.generations[0]) == 1, "Unconsidered Case."
    return {
        "messages": _normalize_langmem_messages(
            [[response.generations[0][0].message]]
        )
    } 
    

def memory_construction(
    layer_type: str, 
    user_id: str, 
    trajectory: Trajectory, 
    config: Optional[Dict[str, Any]] = None, 
    rerun: bool = False,
    message_preprocessor: Optional[
        Callable[[Message | QuestionAnswerPair, Session], Dict[str, Any]]
    ] = None,
    **kwargs
) -> Dict[str, float]: 
    """Given a specific interaction trajectory, this function builds a memory."""
    config = config or {}
    llm_model = config["llm_model"]
    # It overrides the user_id in the config. 
    config["user_id"] = user_id 
    # Each user has a distinct config directory. 
    config["save_dir"] = f"{layer_type}_{llm_model}/{user_id}" 
    # Use lazy mapping to load config and layer classes.
    config_cls = CONFIG_MAPPING[layer_type]
    config = config_cls(**config)
    dataset_type = kwargs["dataset_type"]
    with _LOCK:
        layer_cls = MEMORY_LAYERS_MAPPING[layer_type]
        layer = layer_cls(config)

    output = {
        "total_add_time": 0.0,
        "avg_add_time": 0.0,
    }

    with _LOCK:
        # It includes I/O operations. 
        if not rerun and layer.load_memory(user_id):
            print(f"The memory for user {user_id} is loaded successfully.")
            return output
    
    if layer_type == "A-MEM":
        # In this case, we modify an instance's method. 
        # Other instances are not affected. 
        # Note that there is no need to check `response_format` parameter. 
        getter, setter = make_attr_patch(layer.memory_layer.llm_controller.llm, "get_completion")
        spec = PatchSpec(
            name=f"{layer.memory_layer.llm_controller.llm.__class__.__name__}.get_completion",
            getter=getter,
            setter=setter,
            wrapper=token_monitor(
                extract_model_name=lambda *args, **kwargs: (config.llm_model, {}),
                extract_input_dict=lambda *args, **kwargs: {
                    "messages": [
                        {
                            "role": "system", 
                            "content": "You must respond with a JSON object."
                        }, 
                        {
                            "role": "user",
                            "content": kwargs.get("prompt", args[0]) 
                        }
                    ],
                    "metadata": {
                        "op_type": (
                            "generation"
                            if kwargs.get("prompt", args[0]).startswith("Generate a structured analysis") 
                            else "update"
                        )
                    }
                },
                extract_output_dict=lambda result: {
                    "messages": result
                },
            ),
        )
        specs = [spec]
        patch_ctx = MonkeyPatcher(specs) 
    elif layer_type == "LangMem":
        getter, setter = make_attr_patch(layer.llm_model, "generate")
        spec = PatchSpec(
            name=f"{layer.llm_model.__class__.__name__}.generate",
            getter=getter,
            setter=setter,
            wrapper=token_monitor(
                extract_model_name=lambda *args, **kwargs: _extract_langmem_model(
                    config.llm_model, 
                    config.query_model, 
                    *args, 
                    **kwargs
                ),
                extract_input_dict=lambda *args, **kwargs: {
                    # NOTE: LangMem uses the same prompt to generate and update memories. 
                    # These two types of operations are handled by the same forward pass of LLMs. 
                    "messages": _normalize_langmem_messages(*args, **kwargs),
                    "metadata": {
                        "op_type": "generation, update"
                    }
                },
                extract_output_dict=lambda response: _extract_langmem_output(response)
            )
        )
        specs = [spec]
        patch_ctx = MonkeyPatcher(specs)
    elif layer_type in ("MemZero", "MemZeroGraph"):
        getter, setter = make_attr_patch(layer.memory_layer.llm, "generate_response")
        spec = PatchSpec(
            name=f"{layer.memory_layer.llm.__class__.__name__}.generate_response",
            getter=getter,
            setter=setter,
            wrapper=token_monitor(
                extract_model_name = lambda *args, **kwargs: (config.llm_model, {}),
                extract_input_dict = lambda *args, **kwargs: {
                    # keyword arguments
                    "messages": kwargs["messages"],
                    "metadata": {
                        "op_type": (
                            "generation" if kwargs["messages"][0]["content"].startswith("You are a Personal Information Organizer") else "update"
                        )
                    }
                },
                # generate_response has parsed the output
                extract_output_dict = lambda response: {"messages": response.get("content", "")} if isinstance(response, dict) else {"messages": response}
            )
        )
        specs = [spec]
        patch_ctx = MonkeyPatcher(specs)
    elif layer_type == "FullContext":
        # No need to patch any method for FullContext layer. 
        patch_ctx = nullcontext()
    elif layer_type == "NaiveRAG":
        # No need to patch any method for NaiveRAG layer. 
        patch_ctx = nullcontext()
    else:
        raise ValueError(f"Unsupported memory type: {layer_type}.")

    
    with patch_ctx:
        total_msgs = sum(len(session) for session in trajectory)

        pbar_desc = f" {layer_type} | {user_id}"
        pbar = tqdm(
            total=total_msgs,
            desc=pbar_desc,
            leave=False,   
        )
        # Start to construct the memory for a specific trajectory. 
        for session in trajectory:
            # TODO: take the case that the message is a question-answe pair into the consideration 
            for message in session:
                start_time = datetime.now() 
                msg_dict = {"role": message.role, "content": message.content}
                if message_preprocessor is not None:
                    msg_dict = message_preprocessor(message, session)
                
                timestamp = session.get_string_timestamp()
                layer.add_message(
                    msg_dict, 
                    timestamp=timestamp
                )

                end_time = datetime.now() 
                output["total_add_time"] += (end_time - start_time).total_seconds()

                pbar.update(1)

                time.sleep(0.2)
        pbar.close()

    
    if layer_type == "A-MEM":
        # It includes I/O operations (loading a sentence embedding model).
        with _LOCK:
            layer.consolidate_memories()
    # It includes I/O operations. 
    with _LOCK:
        layer.save_memory() 

    output["avg_add_time"] = output["total_add_time"] / len(trajectory)

    return output 

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="A script used to evaluate various memory layers on various datasets."
    )
    parser.add_argument(
        "--memory-type", 
        choices=list(MEMORY_LAYERS_MAPPING.keys()), 
        type=str, 
        required=True, 
        help="The type of the memory layer to be evaluated."
    )
    parser.add_argument(
        "--dataset-type", 
        choices=list(DATASET_MAPPING.keys()), 
        type=str, 
        required=True, 
        help="The type of the dataset used to evaluate 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 evaluation."
    )
    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(
        "--rerun", 
        action="store_true", 
        help="Ignore saved memory; rebuild from scratch."
    )
    parser.add_argument(
        "--config-path", 
        type=str, 
        default=None,
        help="Path to JSON config for memory method."
    )
    parser.add_argument(
        "--token-cost-save-filename", 
        type=str, 
        default="token_cost", 
        help="Path to save the statistics related to the token consumption."
    )
    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(
        "--tokenizer-path", 
        type=str, 
        default=None, 
        help="The path to the tokenizer (only for backbone model)."
    )
    parser.add_argument(
        "--message-preprocessor",
        type=str,
        default=None,
        help=(
            "Dotted path to a message preprocessor function, in the form "
            "'some_module:some_function'. The function should accept "
            "(message, session) and return a dict with at least 'role' "
            "and 'content' keys."
        )
    )
    parser.add_argument(
        "--use-gpt4o-caption",
        action="store_true",
        default=False,
        help=(
            "If set, use GPT-4o to generate image captions in datasets that support it "
            "(e.g., LoCoMo)."
        )
    )
    args = parser.parse_args()

    message_preprocessor = None
    if args.message_preprocessor is not None:
        module_path, func_name = args.message_preprocessor.split(":", 1)
        module = import_module(module_path)
        message_preprocessor = getattr(module, func_name)
    
    if args.use_gpt4o_caption:
        os.environ["USE_GPT4O_CAPTION"] = "1"
    else:
        os.environ["USE_GPT4O_CAPTION"] = "0"

    # 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.")
    # print(dataset) calls the __str__ method defined by Pydantic's BaseModel
    print(repr(dataset))
    print()

    config = None 
    if args.config_path is not None:
        with open(args.config_path, 'r', encoding="utf-8") as f:
            config = json.load(f)

    # Get a dummy configuration to infer the corresponding LLM being used 
    # Use lazy mapping to load config class
    config_cls = CONFIG_MAPPING[args.memory_type]
    if config is None:
        dummy_user_id = "guest" 
        dummy_config = config_cls(user_id=dummy_user_id)
    else:
        dummy_config = config_cls(**config) 
    
    # If token cost file exists, we load it. 
    if os.path.exists(args.token_cost_save_filename + ".json"):
        with open(args.token_cost_save_filename + ".json", 'r') as f:
            token_cost = json.load(f)
        for model, state in token_cost.items():
            is_dict = all(isinstance(value, dict) for value in state.values())
            if not is_dict:
                token_cost[model] = CostState.from_dict(state)
            else:
                token_cost[model] = {
                    op: CostState.from_dict(cs) for op, cs in state.items()
                }
    else: 
        token_cost = {} 
    
    # Before run the expriment, we should register the base model being used. 
    # Please ensure all types of config classes have a `llm_model` attribute. 
    # The tokenizer is inferred from the model name automatically. 
    llm_model = dummy_config.llm_model
    if args.memory_type == "LangMem":
        llm_model = llm_model.split(':', 1)[1]
        if dummy_config.query_model is not None:
            query_model = dummy_config.query_model.split(':', 1)[1]
            if query_model != llm_model:
                state = token_cost.get(query_model)
                if state is not None: 
                    print(
                        f"There is a saved checkpoint for monitoring the token consumption of {query_model}. "
                        "It will be loaded into `CostStateManager`."
                    )
                CostStateManager.register(query_model, state=state)
    state = token_cost.get(llm_model)
    if state is not None: 
        print(
            f"There is a saved checkpoint for monitoring the token consumption of {llm_model}. "
            "It will be loaded into `CostStateManager`."
        )
    if args.tokenizer_path is not None:
        tokenizer = get_tokenizer_for_model(args.tokenizer_path)
    else:
        tokenizer = None 
    CostStateManager.register(llm_model, state=state, tokenizer=tokenizer)
    del dummy_config 
    print(f"The LLM model being used is {llm_model}. It has been registered in `CostStateManager`.")
    print()

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

    results = [] 
    with ThreadPoolExecutor(max_workers=args.num_workers) as executor:
        futures = []
        for trajectory, _ in zip(*dataset[args.start_idx: args.end_idx]):
            # Note that this code is for academic purpose, the embedding model will be loaded multiple times. 
            user_id = f"user_{dataset.__class__.__name__}_{trajectory.metadata['id']}"
            future = executor.submit(
                memory_construction, 
                args.memory_type, 
                user_id, 
                trajectory, 
                config=deepcopy(config), 
                rerun=args.rerun,
                message_preprocessor=message_preprocessor,
                dataset_type=args.dataset_type
            )
            futures.append(future)
        for future in tqdm(
            as_completed(futures), total=len(futures), desc="Processing trajectories"
        ):
            try:
                result = future.result()
                results.append(result)
            except Exception as e:
                print(f"Error processing trajectory: {e}")

    if len(results) == args.end_idx - args.start_idx:
        print("The memory construction process is completed successfully.")

    total_time = 0.0 
    avg_time_per_add_session = 0.0 
    num_vaild_trajectories = 0
    for result in results: 
        # Statistics on the newly processed trajectories
        if result["total_add_time"] > 0:
            total_time += result["total_add_time"]
            avg_time_per_add_session += result["avg_add_time"]
            num_vaild_trajectories += 1 
    avg_time = total_time / max(num_vaild_trajectories, 1)
    avg_time_per_add_session = avg_time_per_add_session / max(num_vaild_trajectories, 1)
    print(
        f"For {args.memory_type}, the average time per trajectory "
        f"({num_vaild_trajectories} in {len(results)}) is {avg_time:.2f} seconds."
    )
    print(
        f"For {args.memory_type}, the average time per operation of adding new session " 
        f"is {avg_time_per_add_session:.2f} seconds."
    )

    # Save the statistics of token comsumption 
    CostStateManager.save_to_json_file(args.token_cost_save_filename)
    CostStateManager.reset() 

	import argparse
	import json
	from concurrent.futures import ThreadPoolExecutor, as_completed
	from datetime import datetime
	from tqdm import tqdm
	import time
	import threading
	from importlib.util import find_spec
	from copy import deepcopy
	import os
	from contextlib import nullcontext

	from token_monitor import (
	CostStateManager,
	token_monitor,
	CostState,
	get_tokenizer_for_model,
	)
	from monkey_patch import (
	PatchSpec,
	MonkeyPatcher,
	make_attr_patch,
	)

	from memories import (
	CONFIG_MAPPING,
	MEMORY_LAYERS_MAPPING,
	DATASET_MAPPING,
	)
	from memories.datasets.base import Trajectory
	from typing import (
	Dict,
	Any,
	Optional,
	Tuple,
	List,
	Callable,
	)
	from memories.datasets.base import Trajectory, Message, QuestionAnswerPair, Session
	from importlib import import_module

	_LOCK = threading.Lock()

	def _check_langchain_core_imports() -> None:
	"""Check if `langchain_core` is installed."""
	if find_spec("langchain_core") is None:
	raise ImportError("`langchain_core` is not installed. Please install it to use this function.")

	def _normalize_langmem_messages(args, *kwargs) -> Dict[str, List[Dict[str, str]] \| str \| float \| int]:
	"""A helper function to process the messages of LangMem."""
	_check_langchain_core_imports()
	from langchain_core.messages import (
	HumanMessage,
	SystemMessage,
	AIMessage,
	ToolMessage,
	)

	messages = kwargs.get("messages", args[0])
	assert len(messages) == 1, "Unconsidered Case."
	messages = messages[0]
	normalized_messages = []
	for message in messages:
	if isinstance(message, SystemMessage):
	normalized_messages.append(
	{
	"role": "system",
	"content": message.content
	}
	)
	elif isinstance(message, HumanMessage):
	normalized_messages.append(
	{
	"role": "user",
	"content": message.content
	}
	)
	elif isinstance(message, AIMessage):
	if message.content is not None and not isinstance(message.content, str):
	raise ValueError(
	f"The content of the message is not a string: {type(message.content)}."
	)
	normalized_messages.append(
	{
	"role": "assistant",
	"content": message.content,
	"tool_calls": [
	{
	"id": tool_call["id"],
	"type": "function",
	"function": {
	"name": tool_call["name"],
	"arguments": str(tool_call["args"]),
	}
	}
	for tool_call in message.tool_calls
	],
	}
	)
	elif isinstance(message, ToolMessage):
	# See https://platform.openai.com/docs/guides/function-calling
	normalized_messages.append(
	{
	"role": "tool",
	"tool_call_id": message.tool_call_id,
	"content": message.content,
	}
	)
	else:
	raise ValueError(f"Unsupported message type: {type(message)}.")

	return normalized_messages

	def _extract_langmem_model(
	llm_model: str,
	query_model: Optional[str],
	*args,
	**kwargs
	) -> Tuple[str, Dict[str, Any]]:
	"""A helper function to extract the model name and metadata for LangMem."""
	_check_langchain_core_imports()
	from langchain_core.messages import HumanMessage

	llm_model = llm_model.split(':', 1)[1]
	query_model = query_model.split(':', 1)[1] if query_model is not None else None

	messages = kwargs.get("messages", args[0])
	assert len(messages) == 1, "Unconsidered Case."
	messages = messages[0]
	# The following parameters are used in LiteLLM's token counter.
	metadata = {
	"tools": kwargs.get("tools"),
	"tool_choice": kwargs.get("tool_choice"),
	}
	if isinstance(messages[0], HumanMessage) and messages[0].content.startswith(
	"Use parallel tool calling to search for distinct memories relevant to this conversation."
	):
	if query_model is None:
	raise ValueError("Query model is not provided.")
	return query_model, metadata
	return llm_model, metadata

	def _extract_langmem_output(response) -> Dict[str, List[Dict[str, str]] \| str \| float \| int]:
	"""A helper function to extract the output for LangMem."""
	assert len(response.generations) == 1, "Unconsidered Case."
	assert len(response.generations[0]) == 1, "Unconsidered Case."
	return {
	"messages": _normalize_langmem_messages(
	[[response.generations[0][0].message]]
	)
	}


	def memory_construction(
	layer_type: str,
	user_id: str,
	trajectory: Trajectory,
	config: Optional[Dict[str, Any]] = None,
	rerun: bool = False,
	message_preprocessor: Optional[
	Callable[[Message \| QuestionAnswerPair, Session], Dict[str, Any]]
	] = None,
	**kwargs
	) -> Dict[str, float]:
	"""Given a specific interaction trajectory, this function builds a memory."""
	config = config or {}
	llm_model = config["llm_model"]
	# It overrides the user_id in the config.
	config["user_id"] = user_id
	# Each user has a distinct config directory.
	config["save_dir"] = f"{layer_type}_{llm_model}/{user_id}"
	# Use lazy mapping to load config and layer classes.
	config_cls = CONFIG_MAPPING[layer_type]
	config = config_cls(**config)
	dataset_type = kwargs["dataset_type"]
	with _LOCK:
	layer_cls = MEMORY_LAYERS_MAPPING[layer_type]
	layer = layer_cls(config)

	output = {
	"total_add_time": 0.0,
	"avg_add_time": 0.0,
	}

	with _LOCK:
	# It includes I/O operations.
	if not rerun and layer.load_memory(user_id):
	print(f"The memory for user {user_id} is loaded successfully.")
	return output

	if layer_type == "A-MEM":
	# In this case, we modify an instance's method.
	# Other instances are not affected.
	# Note that there is no need to check `response_format` parameter.
	getter, setter = make_attr_patch(layer.memory_layer.llm_controller.llm, "get_completion")
	spec = PatchSpec(
	name=f"{layer.memory_layer.llm_controller.llm.__class__.__name__}.get_completion",
	getter=getter,
	setter=setter,
	wrapper=token_monitor(
	extract_model_name=lambda args, *kwargs: (config.llm_model, {}),
	extract_input_dict=lambda args, *kwargs: {
	"messages": [
	{
	"role": "system",
	"content": "You must respond with a JSON object."
	},
	{
	"role": "user",
	"content": kwargs.get("prompt", args[0])
	}
	],
	"metadata": {
	"op_type": (
	"generation"
	if kwargs.get("prompt", args[0]).startswith("Generate a structured analysis")
	else "update"
	)
	}
	},
	extract_output_dict=lambda result: {
	"messages": result
	},
	),
	)
	specs = [spec]
	patch_ctx = MonkeyPatcher(specs)
	elif layer_type == "LangMem":
	getter, setter = make_attr_patch(layer.llm_model, "generate")
	spec = PatchSpec(
	name=f"{layer.llm_model.__class__.__name__}.generate",
	getter=getter,
	setter=setter,
	wrapper=token_monitor(
	extract_model_name=lambda args, *kwargs: _extract_langmem_model(
	config.llm_model,
	config.query_model,
	*args,
	**kwargs
	),
	extract_input_dict=lambda args, *kwargs: {
	# NOTE: LangMem uses the same prompt to generate and update memories.
	# These two types of operations are handled by the same forward pass of LLMs.
	"messages": _normalize_langmem_messages(args, *kwargs),
	"metadata": {
	"op_type": "generation, update"
	}
	},
	extract_output_dict=lambda response: _extract_langmem_output(response)
	)
	)
	specs = [spec]
	patch_ctx = MonkeyPatcher(specs)
	elif layer_type in ("MemZero", "MemZeroGraph"):
	getter, setter = make_attr_patch(layer.memory_layer.llm, "generate_response")
	spec = PatchSpec(
	name=f"{layer.memory_layer.llm.__class__.__name__}.generate_response",
	getter=getter,
	setter=setter,
	wrapper=token_monitor(
	extract_model_name = lambda args, *kwargs: (config.llm_model, {}),
	extract_input_dict = lambda args, *kwargs: {
	# keyword arguments
	"messages": kwargs["messages"],
	"metadata": {
	"op_type": (
	"generation" if kwargs["messages"][0]["content"].startswith("You are a Personal Information Organizer") else "update"
	)
	}
	},
	# generate_response has parsed the output
	extract_output_dict = lambda response: {"messages": response.get("content", "")} if isinstance(response, dict) else {"messages": response}
	)
	)
	specs = [spec]
	patch_ctx = MonkeyPatcher(specs)
	elif layer_type == "FullContext":
	# No need to patch any method for FullContext layer.
	patch_ctx = nullcontext()
	elif layer_type == "NaiveRAG":
	# No need to patch any method for NaiveRAG layer.
	patch_ctx = nullcontext()
	else:
	raise ValueError(f"Unsupported memory type: {layer_type}.")


	with patch_ctx:
	total_msgs = sum(len(session) for session in trajectory)

	pbar_desc = f" {layer_type} \| {user_id}"
	pbar = tqdm(
	total=total_msgs,
	desc=pbar_desc,
	leave=False,
	)
	# Start to construct the memory for a specific trajectory.
	for session in trajectory:
	# TODO: take the case that the message is a question-answe pair into the consideration
	for message in session:
	start_time = datetime.now()
	msg_dict = {"role": message.role, "content": message.content}
	if message_preprocessor is not None:
	msg_dict = message_preprocessor(message, session)

	timestamp = session.get_string_timestamp()
	layer.add_message(
	msg_dict,
	timestamp=timestamp
	)

	end_time = datetime.now()
	output["total_add_time"] += (end_time - start_time).total_seconds()

	pbar.update(1)

	time.sleep(0.2)
	pbar.close()


	if layer_type == "A-MEM":
	# It includes I/O operations (loading a sentence embedding model).
	with _LOCK:
	layer.consolidate_memories()
	# It includes I/O operations.
	with _LOCK:
	layer.save_memory()

	output["avg_add_time"] = output["total_add_time"] / len(trajectory)

	return output

	if __name__ == "__main__":
	parser = argparse.ArgumentParser(
	description="A script used to evaluate various memory layers on various datasets."
	)
	parser.add_argument(
	"--memory-type",
	choices=list(MEMORY_LAYERS_MAPPING.keys()),
	type=str,
	required=True,
	help="The type of the memory layer to be evaluated."
	)
	parser.add_argument(
	"--dataset-type",
	choices=list(DATASET_MAPPING.keys()),
	type=str,
	required=True,
	help="The type of the dataset used to evaluate 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 evaluation."
	)
	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(
	"--rerun",
	action="store_true",
	help="Ignore saved memory; rebuild from scratch."
	)
	parser.add_argument(
	"--config-path",
	type=str,
	default=None,
	help="Path to JSON config for memory method."
	)
	parser.add_argument(
	"--token-cost-save-filename",
	type=str,
	default="token_cost",
	help="Path to save the statistics related to the token consumption."
	)
	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(
	"--tokenizer-path",
	type=str,
	default=None,
	help="The path to the tokenizer (only for backbone model)."
	)
	parser.add_argument(
	"--message-preprocessor",
	type=str,
	default=None,
	help=(
	"Dotted path to a message preprocessor function, in the form "
	"'some_module:some_function'. The function should accept "
	"(message, session) and return a dict with at least 'role' "
	"and 'content' keys."
	)
	)
	parser.add_argument(
	"--use-gpt4o-caption",
	action="store_true",
	default=False,
	help=(
	"If set, use GPT-4o to generate image captions in datasets that support it "
	"(e.g., LoCoMo)."
	)
	)
	args = parser.parse_args()

	message_preprocessor = None
	if args.message_preprocessor is not None:
	module_path, func_name = args.message_preprocessor.split(":", 1)
	module = import_module(module_path)
	message_preprocessor = getattr(module, func_name)

	if args.use_gpt4o_caption:
	os.environ["USE_GPT4O_CAPTION"] = "1"
	else:
	os.environ["USE_GPT4O_CAPTION"] = "0"

	# 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.")
	# print(dataset) calls the __str__ method defined by Pydantic's BaseModel
	print(repr(dataset))
	print()

	config = None
	if args.config_path is not None:
	with open(args.config_path, 'r', encoding="utf-8") as f:
	config = json.load(f)

	# Get a dummy configuration to infer the corresponding LLM being used
	# Use lazy mapping to load config class
	config_cls = CONFIG_MAPPING[args.memory_type]
	if config is None:
	dummy_user_id = "guest"
	dummy_config = config_cls(user_id=dummy_user_id)
	else:
	dummy_config = config_cls(**config)

	# If token cost file exists, we load it.
	if os.path.exists(args.token_cost_save_filename + ".json"):
	with open(args.token_cost_save_filename + ".json", 'r') as f:
	token_cost = json.load(f)
	for model, state in token_cost.items():
	is_dict = all(isinstance(value, dict) for value in state.values())
	if not is_dict:
	token_cost[model] = CostState.from_dict(state)
	else:
	token_cost[model] = {
	op: CostState.from_dict(cs) for op, cs in state.items()
	}
	else:
	token_cost = {}

	# Before run the expriment, we should register the base model being used.
	# Please ensure all types of config classes have a `llm_model` attribute.
	# The tokenizer is inferred from the model name automatically.
	llm_model = dummy_config.llm_model
	if args.memory_type == "LangMem":
	llm_model = llm_model.split(':', 1)[1]
	if dummy_config.query_model is not None:
	query_model = dummy_config.query_model.split(':', 1)[1]
	if query_model != llm_model:
	state = token_cost.get(query_model)
	if state is not None:
	print(
	f"There is a saved checkpoint for monitoring the token consumption of {query_model}. "
	"It will be loaded into `CostStateManager`."
	)
	CostStateManager.register(query_model, state=state)
	state = token_cost.get(llm_model)
	if state is not None:
	print(
	f"There is a saved checkpoint for monitoring the token consumption of {llm_model}. "
	"It will be loaded into `CostStateManager`."
	)
	if args.tokenizer_path is not None:
	tokenizer = get_tokenizer_for_model(args.tokenizer_path)
	else:
	tokenizer = None
	CostStateManager.register(llm_model, state=state, tokenizer=tokenizer)
	del dummy_config
	print(f"The LLM model being used is {llm_model}. It has been registered in `CostStateManager`.")
	print()

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

	results = []
	with ThreadPoolExecutor(max_workers=args.num_workers) as executor:
	futures = []
	for trajectory, _ in zip(*dataset[args.start_idx: args.end_idx]):
	# Note that this code is for academic purpose, the embedding model will be loaded multiple times.
	user_id = f"user_{dataset.__class__.__name__}_{trajectory.metadata['id']}"
	future = executor.submit(
	memory_construction,
	args.memory_type,
	user_id,
	trajectory,
	config=deepcopy(config),
	rerun=args.rerun,
	message_preprocessor=message_preprocessor,
	dataset_type=args.dataset_type
	)
	futures.append(future)
	for future in tqdm(
	as_completed(futures), total=len(futures), desc="Processing trajectories"
	):
	try:
	result = future.result()
	results.append(result)
	except Exception as e:
	print(f"Error processing trajectory: {e}")

	if len(results) == args.end_idx - args.start_idx:
	print("The memory construction process is completed successfully.")

	total_time = 0.0
	avg_time_per_add_session = 0.0
	num_vaild_trajectories = 0
	for result in results:
	# Statistics on the newly processed trajectories
	if result["total_add_time"] > 0:
	total_time += result["total_add_time"]
	avg_time_per_add_session += result["avg_add_time"]
	num_vaild_trajectories += 1
	avg_time = total_time / max(num_vaild_trajectories, 1)
	avg_time_per_add_session = avg_time_per_add_session / max(num_vaild_trajectories, 1)
	print(
	f"For {args.memory_type}, the average time per trajectory "
	f"({num_vaild_trajectories} in {len(results)}) is {avg_time:.2f} seconds."
	)
	print(
	f"For {args.memory_type}, the average time per operation of adding new session "
	f"is {avg_time_per_add_session:.2f} seconds."
	)

	# Save the statistics of token comsumption
	CostStateManager.save_to_json_file(args.token_cost_save_filename)
	CostStateManager.reset()