def add_memory(self, memory_item: MemoryItem) -> None:
    """
    Update the memory of the agent.
    :param memory_item: The memory item to add.
    """
    self._memory.add_memory_item(memory_item)

def build_experience_retriever(self) -> None:
    """
    Build the experience retriever.
    """
    pass

def build_human_demonstration_retriever(self) -> None:
    """
    Build the human demonstration retriever.
    """
    pass

def build_offline_docs_retriever(self) -> None:
    """
    Build the offline docs retriever.
    """
    pass

def build_online_search_retriever(self) -> None:
    """
    Build the online search retriever.
    """
    pass

def clear_memory(self) -> None:
    """
    Clear the memory of the agent.
    """
    self._memory.clear()

def create_puppeteer_interface(self) -> puppeteer.AppPuppeteer:
    """
    Create the puppeteer interface.
    """
    pass

def delete_memory(self, step: int) -> None:
    """
    Delete the memory of the agent.
    :param step: The step of the memory item to delete.
    """
    self._memory.delete_memory_item(step)

@classmethod
def get_cls(cls, name: str) -> Type["BasicAgent"]:
    """
    Retrieves an agent class from the registry.
    :param name: The name of the agent class.
    :return: The agent class.
    """
    return AgentRegistry().get_cls(name)

@abstractmethod
def get_prompter(self) -> str:
    """
    Get the prompt for the agent.
    :return: The prompt.
    """
    pass

@classmethod
def get_response(
    cls,
    message: List[dict],
    namescope: str,
    use_backup_engine: bool,
    configs=configs,
) -> str:
    """
    Get the response for the prompt.
    :param message: The message for LLMs.
    :param namescope: The namescope for the LLMs.
    :param use_backup_engine: Whether to use the backup engine.
    :param configs: The configurations.
    :return: The response.
    """
    response_string, cost = llm_call.get_completion(
        message, namescope, use_backup_engine=use_backup_engine, configs=configs
    )
    return response_string, cost

def handle(self, context: Context) -> None:
    """
    Handle the agent.
    :param context: The context for the agent.
    """
    self.state.handle(self, context)

@abstractmethod
def message_constructor(self) -> List[Dict[str, Union[str, List[Dict[str, str]]]]]:
    """
    Construct the message.
    :return: The message.
    """
    pass

def print_response(self) -> None:
    """
    Print the response.
    """
    pass

def process(self, context: Context) -> None:
    """
    Process the agent.
    """
    pass

def process_asker(self, ask_user: bool = True) -> None:
    """
    Ask for the process.
    :param ask_user: Whether to ask the user for the questions.
    """

    _ask_message = "Could you please answer the following questions to help me understand your needs and complete the task?"
    _none_answer_message = "The answer for the question is not available, please proceed with your own knowledge or experience, or leave it as a placeholder. Do not ask the same question again."

    if self.processor:
        question_list = self.processor.question_list

        if ask_user:
            utils.print_with_color(
                _ask_message,
                "yellow",
            )

        for index, question in enumerate(question_list):
            if ask_user:
                answer = question_asker(question, index + 1)
                if not answer.strip():
                    continue
                qa_pair = {"question": question, "answer": answer}

                utils.append_string_to_file(
                    configs["QA_PAIR_FILE"], json.dumps(qa_pair)
                )

            else:
                qa_pair = {
                    "question": question,
                    "answer": _none_answer_message,
                }

            self.blackboard.add_questions(qa_pair)

@abstractmethod
def process_comfirmation(self) -> None:
    """
    Confirm the process.
    """
    pass

def process_resume(self) -> None:
    """
    Resume the process.
    """
    if self.processor:
        self.processor.resume()

def reflection(self) -> None:
    """
    TODO:
    Reflect on the action.
    """
    pass

@staticmethod
def response_to_dict(response: str) -> Dict[str, str]:
    """
    Convert the response to a dictionary.
    :param response: The response.
    :return: The dictionary.
    """
    return utils.json_parser(response)

def set_memory_from_list_of_dicts(self, data: List[Dict[str, str]]) -> None:
    """
    Set the memory from the list of dictionaries.
    :param data: The list of dictionaries.
    """

    assert isinstance(data, list), "The data should be a list of dictionaries."

    self._memory.from_list_of_dicts(data)

def set_state(self, state: AgentState) -> None:
    """
    Set the state of the agent.
    :param state: The state of the agent.
    """

    assert issubclass(
        type(self), state.agent_class()
    ), f"The state is only for agent type of {state.agent_class()}, but the current agent is {type(self)}."

    self._state = state