MemoryOS 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

memos/mem_scheduler/modules/rabbitmq_service.py

@@ -0,0 +1,319 @@
+import json
+import ssl
+import threading
+import time
+
+from pathlib import Path
+
+from memos.configs.mem_scheduler import AuthConfig, RabbitMQConfig
+from memos.dependency import require_python_package
+from memos.log import get_logger
+from memos.mem_scheduler.modules.base import BaseSchedulerModule
+from memos.mem_scheduler.modules.misc import AutoDroppingQueue
+from memos.mem_scheduler.schemas.general_schemas import DIRECT_EXCHANGE_TYPE, FANOUT_EXCHANGE_TYPE
+
+
+logger = get_logger(__name__)
+
+
+class RabbitMQSchedulerModule(BaseSchedulerModule):
+    @require_python_package(
+        import_name="pika",
+        install_command="pip install pika",
+        install_link="https://pika.readthedocs.io/en/stable/index.html",
+    )
+    def __init__(self):
+        """
+        Initialize RabbitMQ connection settings.
+        """
+        super().__init__()
+
+        # RabbitMQ settings
+        self.rabbitmq_config: RabbitMQConfig | None = None
+        self.rabbit_queue_name = "memos-scheduler"
+        self.rabbitmq_exchange_name = "memos-fanout"
+        self.rabbitmq_exchange_type = FANOUT_EXCHANGE_TYPE
+        self.rabbitmq_connection = None
+        self.rabbitmq_channel = None
+
+        # fixed params
+        self.rabbitmq_message_cache_max_size = 10  # Max 10 messages
+        self.rabbitmq_message_cache = AutoDroppingQueue(
+            maxsize=self.rabbitmq_message_cache_max_size
+        )
+        self.rabbitmq_connection_attempts = 3  # Max retry attempts on connection failure
+        self.rabbitmq_retry_delay = 5  # Delay (seconds) between retries
+        self.rabbitmq_heartbeat = 60  # Heartbeat interval (seconds) for connectio
+        self.rabbitmq_conn_max_waiting_seconds = 30
+        self.rabbitmq_conn_sleep_seconds = 1
+
+        # Thread management
+        self._rabbitmq_io_loop_thread = None  # For IOLoop execution
+        self._rabbitmq_stop_flag = False  # Graceful shutdown flag
+        self._rabbitmq_lock = threading.Lock()  # Ensure thread safety
+
+    def is_rabbitmq_connected(self) -> bool:
+        """Check if RabbitMQ connection is alive"""
+        return (
+            self.rabbitmq_connection
+            and self.rabbitmq_connection.is_open
+            and self.rabbitmq_channel
+            and self.rabbitmq_channel.is_open
+        )
+
+    def initialize_rabbitmq(
+        self, config: dict | None | RabbitMQConfig = None, config_path: str | Path | None = None
+    ):
+        """
+        Establish connection to RabbitMQ using pika.
+        """
+        from pika.adapters.select_connection import SelectConnection
+
+        if config is None:
+            if config_path is None and AuthConfig.default_config_exists():
+                auth_config = AuthConfig.from_local_yaml()
+            elif Path(config_path).exists():
+                auth_config = AuthConfig.from_local_yaml(config_path=config_path)
+            else:
+                logger.error("Fail to initialize auth_config")
+                return
+            self.rabbitmq_config = auth_config.rabbitmq
+        elif isinstance(config, RabbitMQConfig):
+            self.rabbitmq_config = config
+        elif isinstance(config, dict):
+            self.rabbitmq_config = AuthConfig.from_dict(config).rabbitmq
+        else:
+            logger.error("Not implemented")
+
+            # Start connection process
+        parameters = self.get_rabbitmq_connection_param()
+        self.rabbitmq_connection = SelectConnection(
+            parameters,
+            on_open_callback=self.on_rabbitmq_connection_open,
+            on_open_error_callback=self.on_rabbitmq_connection_error,
+            on_close_callback=self.on_rabbitmq_connection_closed,
+        )
+
+        # Start IOLoop in dedicated thread
+        self._io_loop_thread = threading.Thread(
+            target=self.rabbitmq_connection.ioloop.start, daemon=True
+        )
+        self._io_loop_thread.start()
+        logger.info("RabbitMQ connection process started")
+
+    def get_rabbitmq_queue_size(self) -> int:
+        """Get the current number of messages in the queue.
+
+        Returns:
+            int: Number of messages in the queue.
+                 Returns -1 if there's an error or no active connection.
+        """
+        if self.rabbitmq_exchange_type != DIRECT_EXCHANGE_TYPE:
+            logger.warning("Queue size can only be checked for direct exchanges")
+            return None
+
+        with self._rabbitmq_lock:
+            if not self.is_rabbitmq_connected():
+                logger.warning("No active connection to check queue size")
+                return -1
+
+            # Declare queue passively (only checks existence, doesn't create)
+            # Using passive=True prevents accidental queue creation
+            result = self.rabbitmq_channel.queue_declare(
+                queue=self.rabbit_queue_name,
+                durable=True,  # Match the original queue durability setting
+                passive=True,  # Only check queue existence, don't create
+            )
+
+            if result is None:
+                return 0
+            # Return the message count from the queue declaration result
+            return result.method.message_count
+
+    def get_rabbitmq_connection_param(self):
+        import pika
+
+        credentials = pika.PlainCredentials(
+            username=self.rabbitmq_config.user_name,
+            password=self.rabbitmq_config.password,
+            erase_on_connect=self.rabbitmq_config.erase_on_connect,
+        )
+        if self.rabbitmq_config.port == 5671:
+            context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            context.check_hostname = False
+            context.verify_mode = False
+            return pika.ConnectionParameters(
+                host=self.rabbitmq_config.host_name,
+                port=self.rabbitmq_config.port,
+                virtual_host=self.rabbitmq_config.virtual_host,
+                credentials=credentials,
+                ssl_options=pika.SSLOptions(context),
+                connection_attempts=self.rabbitmq_connection_attempts,
+                retry_delay=self.rabbitmq_retry_delay,
+                heartbeat=self.rabbitmq_heartbeat,
+            )
+        else:
+            return pika.ConnectionParameters(
+                host=self.rabbitmq_config.host_name,
+                port=self.rabbitmq_config.port,
+                virtual_host=self.rabbitmq_config.virtual_host,
+                credentials=credentials,
+                connection_attempts=self.rabbitmq_connection_attempts,
+                retry_delay=self.rabbitmq_retry_delay,
+                heartbeat=self.rabbitmq_heartbeat,
+            )
+
+    # Connection lifecycle callbacks
+    def on_rabbitmq_connection_open(self, connection):
+        """Called when connection is established."""
+        logger.debug("Connection opened")
+        connection.channel(on_open_callback=self.on_rabbitmq_channel_open)
+
+    def on_rabbitmq_connection_error(self, connection, error):
+        """Called if connection fails to open."""
+        logger.error(f"Connection failed: {error}")
+        self.rabbit_reconnect()
+
+    def on_rabbitmq_connection_closed(self, connection, reason):
+        """Called when connection closes."""
+        logger.warning(f"Connection closed: {reason}")
+        if not self._rabbitmq_stop_flag:
+            self.rabbit_reconnect()
+
+    # Channel lifecycle callbacks
+    def on_rabbitmq_channel_open(self, channel):
+        """Called when channel is ready."""
+        self.rabbitmq_channel = channel
+        logger.debug("Channel opened")
+
+        # Setup exchange and queue
+        channel.exchange_declare(
+            exchange=self.rabbitmq_exchange_name,
+            exchange_type=self.rabbitmq_exchange_type,
+            durable=True,
+            callback=self.on_rabbitmq_exchange_declared,
+        )
+
+    def on_rabbitmq_exchange_declared(self, frame):
+        """Called when exchange is ready."""
+        self.rabbitmq_channel.queue_declare(
+            queue=self.rabbit_queue_name, durable=True, callback=self.on_rabbitmq_queue_declared
+        )
+
+    def on_rabbitmq_queue_declared(self, frame):
+        """Called when queue is ready."""
+        self.rabbitmq_channel.queue_bind(
+            exchange=self.rabbitmq_exchange_name,
+            queue=self.rabbit_queue_name,
+            routing_key=self.rabbit_queue_name,
+            callback=self.on_rabbitmq_bind_ok,
+        )
+
+    def on_rabbitmq_bind_ok(self, frame):
+        """Final setup step when bind is complete."""
+        logger.info("RabbitMQ setup completed")
+
+    def on_rabbitmq_message(self, channel, method, properties, body):
+        """Handle incoming messages. Only for test."""
+        try:
+            print(f"Received message: {body.decode()}\n")
+            self.rabbitmq_message_cache.put({"properties": properties, "body": body})
+            print(f"message delivery_tag: {method.delivery_tag}\n")
+            channel.basic_ack(delivery_tag=method.delivery_tag)
+        except Exception as e:
+            logger.error(f"Message handling failed: {e}", exc_info=True)
+
+    def wait_for_connection_ready(self):
+        start_time = time.time()
+        while not self.is_rabbitmq_connected():
+            delta_time = time.time() - start_time
+            if delta_time > self.rabbitmq_conn_max_waiting_seconds:
+                logger.error("Failed to start consuming: Connection timeout")
+                return False
+            self.rabbit_reconnect()
+            time.sleep(self.rabbitmq_conn_sleep_seconds)  # Reduced frequency of checks
+
+    # Message handling
+    def rabbitmq_start_consuming(self):
+        """Start consuming messages asynchronously."""
+        self.wait_for_connection_ready()
+
+        self.rabbitmq_channel.basic_consume(
+            queue=self.rabbit_queue_name,
+            on_message_callback=self.on_rabbitmq_message,
+            auto_ack=False,
+        )
+        logger.info("Started rabbitmq consuming messages")
+
+    def rabbitmq_publish_message(self, message: dict):
+        """
+        Publish a message to RabbitMQ.
+        """
+        import pika
+
+        with self._rabbitmq_lock:
+            if not self.is_rabbitmq_connected():
+                logger.error("Cannot publish - no active connection")
+                return False
+
+            try:
+                self.rabbitmq_channel.basic_publish(
+                    exchange=self.rabbitmq_exchange_name,
+                    routing_key=self.rabbit_queue_name,
+                    body=json.dumps(message),
+                    properties=pika.BasicProperties(
+                        delivery_mode=2,  # Persistent
+                    ),
+                    mandatory=True,
+                )
+                logger.debug(f"Published message: {message}")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to publish message: {e}")
+                self.rabbit_reconnect()
+                return False
+
+    # Connection management
+    def rabbit_reconnect(self):
+        """Schedule reconnection attempt."""
+        logger.info("Attempting to reconnect...")
+        if self.rabbitmq_connection and not self.rabbitmq_connection.is_closed:
+            self.rabbitmq_connection.ioloop.stop()
+
+        # Reset connection state
+        self.rabbitmq_channel = None
+        self.initialize_rabbitmq()
+
+    def rabbitmq_close(self):
+        """Gracefully shutdown connection."""
+        with self._rabbitmq_lock:
+            self._rabbitmq_stop_flag = True
+
+            # Close channel if open
+            if self.rabbitmq_channel and self.rabbitmq_channel.is_open:
+                try:
+                    self.rabbitmq_channel.close()
+                except Exception as e:
+                    logger.warning(f"Error closing channel: {e}")
+
+            # Close connection if open
+            if self.rabbitmq_connection:
+                if self.rabbitmq_connection.is_open:
+                    try:
+                        self.rabbitmq_connection.close()
+                    except Exception as e:
+                        logger.warning(f"Error closing connection: {e}")
+
+                # Stop IOLoop if running
+                try:
+                    self.rabbitmq_connection.ioloop.stop()
+                except Exception as e:
+                    logger.warning(f"Error stopping IOLoop: {e}")
+
+            # Wait for IOLoop thread to finish
+            if self._io_loop_thread and self._io_loop_thread.is_alive():
+                self._io_loop_thread.join(timeout=5)
+                if self._io_loop_thread.is_alive():
+                    logger.warning("IOLoop thread did not terminate cleanly")
+
+        logger.info("RabbitMQ connection closed")

memos/mem_scheduler/modules/redis_service.py

@@ -2,11 +2,9 @@ import asyncio
 import threading
 
 from collections.abc import Callable
+from typing import Any
 
-import redis
-
-from redis import Redis
-
+from memos.dependency import require_python_package
 from memos.log import get_logger
 from memos.mem_scheduler.modules.base import BaseSchedulerModule
 
@@ -15,6 +13,11 @@ logger = get_logger(__name__)
 
 
 class RedisSchedulerModule(BaseSchedulerModule):
+    @require_python_package(
+        import_name="redis",
+        install_command="pip install redis",
+        install_link="https://redis.readthedocs.io/en/stable/",
+    )
     def __init__(self):
         """
         intent_detector: Object used for intent recognition (such as the above IntentDetector)
@@ -35,23 +38,25 @@ class RedisSchedulerModule(BaseSchedulerModule):
         self._redis_listener_loop: asyncio.AbstractEventLoop | None = None
 
     @property
-    def redis(self) -> Redis:
+    def redis(self) -> Any:
         return self._redis_conn
 
     @redis.setter
-    def redis(self, value: Redis) -> None:
+    def redis(self, value: Any) -> None:
         self._redis_conn = value
 
     def initialize_redis(
         self, redis_host: str = "localhost", redis_port: int = 6379, redis_db: int = 0
     ):
+        import redis
+
         self.redis_host = redis_host
         self.redis_port = redis_port
         self.redis_db = redis_db
 
         try:
             logger.debug(f"Connecting to Redis at {redis_host}:{redis_port}/{redis_db}")
-            self._redis_conn = Redis(
+            self._redis_conn = redis.Redis(
                 host=self.redis_host, port=self.redis_port, db=self.redis_db, decode_responses=True
             )
             # test conn
@@ -63,21 +68,21 @@ class RedisSchedulerModule(BaseSchedulerModule):
         self._redis_conn.xtrim("user:queries:stream", self.query_list_capacity)
         return self._redis_conn
 
-    async def add_message_stream(self, message: dict):
+    async def redis_add_message_stream(self, message: dict):
         logger.debug(f"add_message_stream: {message}")
         return self._redis_conn.xadd("user:queries:stream", message)
 
-    async def consume_message_stream(self, message: dict):
+    async def redis_consume_message_stream(self, message: dict):
         logger.debug(f"consume_message_stream: {message}")
 
-    def _run_listener_async(self, handler: Callable):
+    def _redis_run_listener_async(self, handler: Callable):
         """Run the async listener in a separate thread"""
         self._redis_listener_loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self._redis_listener_loop)
 
         async def listener_wrapper():
             try:
-                await self._listen_query_stream(handler)
+                await self.__redis_listen_query_stream(handler)
             except Exception as e:
                 logger.error(f"Listener thread error: {e}")
             finally:
@@ -85,8 +90,12 @@ class RedisSchedulerModule(BaseSchedulerModule):
 
         self._redis_listener_loop.run_until_complete(listener_wrapper())
 
-    async def _listen_query_stream(self, handler=None, last_id: str = "$", block_time: int = 2000):
+    async def __redis_listen_query_stream(
+        self, handler=None, last_id: str = "$", block_time: int = 2000
+    ):
         """Internal async stream listener"""
+        import redis
+
         self._redis_listener_running = True
         while self._redis_listener_running:
             try:
@@ -99,6 +108,7 @@ class RedisSchedulerModule(BaseSchedulerModule):
                     for _, stream_messages in messages:
                         for message_id, message_data in stream_messages:
                             try:
+                                print(f"deal with message_data {message_data}")
                                 await handler(message_data)
                                 last_id = message_id
                             except Exception as e:
@@ -112,17 +122,17 @@ class RedisSchedulerModule(BaseSchedulerModule):
                 logger.error(f"Unexpected error: {e}")
                 await asyncio.sleep(1)
 
-    def start_listening(self, handler: Callable | None = None):
+    def redis_start_listening(self, handler: Callable | None = None):
         """Start the Redis stream listener in a background thread"""
         if self._redis_listener_thread and self._redis_listener_thread.is_alive():
             logger.warning("Listener is already running")
             return
 
         if handler is None:
-            handler = self.consume_message_stream
+            handler = self.redis_consume_message_stream
 
         self._redis_listener_thread = threading.Thread(
-            target=self._run_listener_async,
+            target=self._redis_run_listener_async,
             args=(handler,),
             daemon=True,
             name="RedisListenerThread",
@@ -130,13 +140,7 @@ class RedisSchedulerModule(BaseSchedulerModule):
         self._redis_listener_thread.start()
         logger.info("Started Redis stream listener thread")
 
-    def close(self):
-        """Close Redis connection"""
-        if self._redis_conn is not None:
-            self._redis_conn.close()
-            self._redis_conn = None
-
-    def stop_listening(self):
+    def redis_stop_listening(self):
         """Stop the listener thread gracefully"""
         self._redis_listener_running = False
         if self._redis_listener_thread and self._redis_listener_thread.is_alive():
@@ -144,3 +148,9 @@ class RedisSchedulerModule(BaseSchedulerModule):
             if self._redis_listener_thread.is_alive():
                 logger.warning("Listener thread did not stop gracefully")
         logger.info("Redis stream listener stopped")
+
+    def redis_close(self):
+        """Close Redis connection"""
+        if self._redis_conn is not None:
+            self._redis_conn.close()
+            self._redis_conn = None

memos/mem_scheduler/modules/retriever.py

@@ -1,41 +1,185 @@
+from memos.configs.mem_scheduler import BaseSchedulerConfig
+from memos.llms.base import BaseLLM
 from memos.log import get_logger
+from memos.mem_cube.general import GeneralMemCube
 from memos.mem_scheduler.modules.base import BaseSchedulerModule
+from memos.mem_scheduler.schemas.general_schemas import (
+    TreeTextMemory_SEARCH_METHOD,
+)
+from memos.mem_scheduler.utils.filter_utils import (
+    filter_similar_memories,
+    filter_too_short_memories,
+    transform_name_to_key,
+)
+from memos.mem_scheduler.utils.misc_utils import (
+    extract_json_dict,
+)
+from memos.memories.textual.tree import TextualMemoryItem, TreeTextMemory
 
 
 logger = get_logger(__name__)
 
 
 class SchedulerRetriever(BaseSchedulerModule):
-    def __init__(self, chat_llm, context_window_size=5):
+    def __init__(self, process_llm: BaseLLM, config: BaseSchedulerConfig):
+        super().__init__()
+
+        # hyper-parameters
+        self.filter_similarity_threshold = 0.75
+        self.filter_min_length_threshold = 6
+
+        self.config: BaseSchedulerConfig = config
+        self.process_llm = process_llm
+
+    def search(
+        self, query: str, mem_cube: GeneralMemCube, top_k: int, method=TreeTextMemory_SEARCH_METHOD
+    ) -> list[TextualMemoryItem]:
+        """Search in text memory with the given query.
+
+        Args:
+            query: The search query string
+            top_k: Number of top results to return
+            method: Search method to use
+
+        Returns:
+            Search results or None if not implemented
         """
-        monitor: Object used to acquire monitoring information
-        mem_cube: Object/interface for querying the underlying database
-        context_window_size: Size of the context window for conversation history
+        text_mem_base = mem_cube.text_mem
+        try:
+            if method == TreeTextMemory_SEARCH_METHOD:
+                assert isinstance(text_mem_base, TreeTextMemory)
+                results_long_term = text_mem_base.search(
+                    query=query, top_k=top_k, memory_type="LongTermMemory"
+                )
+                results_user = text_mem_base.search(
+                    query=query, top_k=top_k, memory_type="UserMemory"
+                )
+                results = results_long_term + results_user
+            else:
+                raise NotImplementedError(str(type(text_mem_base)))
+        except Exception as e:
+            logger.error(f"Fail to search. The exeption is {e}.", exc_info=True)
+            results = []
+        return results
+
+    def rerank_memories(
+        self,
+        queries: list[str],
+        original_memories: list[str],
+        top_k: int,
+    ) -> (list[str], bool):
         """
-        super().__init__()
+        Rerank memories based on relevance to given queries using LLM.
+
+        Args:
+            queries: List of query strings to determine relevance
+            original_memories: List of memory strings to be reranked
+            top_k: Number of top memories to return after reranking
 
-        self.monitors = {}
-        self.context_window_size = context_window_size
+        Returns:
+            List of reranked memory strings (length <= top_k)
+
+        Note:
+            If LLM reranking fails, falls back to original order (truncated to top_k)
+        """
+        success_flag = False
 
-        self._chat_llm = chat_llm
-        self._current_mem_cube = None
+        logger.info(f"Starting memory reranking for {len(original_memories)} memories")
 
-    @property
-    def memory_texts(self) -> list[str]:
-        """The memory cube associated with this MemChat."""
-        return self._memory_text_list
+        # Build LLM prompt for memory reranking
+        prompt = self.build_prompt(
+            "memory_reranking",
+            queries=[f"[0] {queries[0]}"],
+            current_order=[f"[{i}] {mem}" for i, mem in enumerate(original_memories)],
+        )
+        logger.debug(f"Generated reranking prompt: {prompt[:200]}...")  # Log first 200 chars
 
-    @memory_texts.setter
-    def memory_texts(self, value: list[str]) -> None:
-        """The memory cube associated with this MemChat."""
-        self._memory_text_list = value
+        # Get LLM response
+        response = self.process_llm.generate([{"role": "user", "content": prompt}])
+        logger.debug(f"Received LLM response: {response[:200]}...")  # Log first 200 chars
 
-    def fetch_context(self):
+        try:
+            # Parse JSON response
+            response = extract_json_dict(response)
+            new_order = response["new_order"][:top_k]
+            text_memories_with_new_order = [original_memories[idx] for idx in new_order]
+            logger.info(
+                f"Successfully reranked memories. Returning top {len(text_memories_with_new_order)} items;"
+                f"Ranking reasoning: {response['reasoning']}"
+            )
+            success_flag = True
+        except Exception as e:
+            logger.error(
+                f"Failed to rerank memories with LLM. Exception: {e}. Raw response: {response} ",
+                exc_info=True,
+            )
+            text_memories_with_new_order = original_memories[:top_k]
+            success_flag = False
+        return text_memories_with_new_order, success_flag
+
+    def process_and_rerank_memories(
+        self,
+        queries: list[str],
+        original_memory: list[TextualMemoryItem],
+        new_memory: list[TextualMemoryItem],
+        top_k: int = 10,
+    ) -> list[TextualMemoryItem] | None:
         """
-        Extract the context window from the current conversation
-        conversation_history: a list (in chronological order)
+        Process and rerank memory items by combining original and new memories,
+        applying filters, and then reranking based on relevance to queries.
+
+        Args:
+            queries: List of query strings to rerank memories against
+            original_memory: List of original TextualMemoryItem objects
+            new_memory: List of new TextualMemoryItem objects to merge
+            top_k: Maximum number of memories to return after reranking
+
+        Returns:
+            List of reranked TextualMemoryItem objects, or None if processing fails
         """
-        return self._memory_text_list[-self.context_window_size :]
+        # Combine original and new memories into a single list
+        combined_memory = original_memory + new_memory
+
+        # Create a mapping from normalized text to memory objects
+        memory_map = {
+            transform_name_to_key(name=mem_obj.memory): mem_obj for mem_obj in combined_memory
+        }
+
+        # Extract normalized text representations from all memory items
+        combined_text_memory = [m.memory for m in combined_memory]
+
+        # Apply similarity filter to remove overly similar memories
+        filtered_combined_text_memory = filter_similar_memories(
+            text_memories=combined_text_memory,
+            similarity_threshold=self.filter_similarity_threshold,
+        )
+
+        # Apply length filter to remove memories that are too short
+        filtered_combined_text_memory = filter_too_short_memories(
+            text_memories=filtered_combined_text_memory,
+            min_length_threshold=self.filter_min_length_threshold,
+        )
+
+        # Ensure uniqueness of memory texts using dictionary keys (preserves order)
+        unique_memory = list(dict.fromkeys(filtered_combined_text_memory))
+
+        # Rerank the filtered memories based on relevance to the queries
+        text_memories_with_new_order, success_flag = self.rerank_memories(
+            queries=queries,
+            original_memories=unique_memory,
+            top_k=top_k,
+        )
+
+        # Map reranked text entries back to their original memory objects
+        memories_with_new_order = []
+        for text in text_memories_with_new_order:
+            normalized_text = transform_name_to_key(name=text)
+            if normalized_text in memory_map:  # Ensure correct key matching
+                memories_with_new_order.append(memory_map[normalized_text])
+            else:
+                logger.warning(
+                    f"Memory text not found in memory map. text: {text};\n"
+                    f"Keys of memory_map: {memory_map.keys()}"
+                )
 
-    def retrieve(self, query: str, memory_texts: list[str], top_k: int = 5) -> list[str]:
-        return None
+        return memories_with_new_order, success_flag