feat: transfer pref to polar db

examples/mem_feedback/example_feedback.py

@@ -144,7 +144,7 @@ def init_components():
         mem_reader=mem_reader,
         searcher=searcher,
         reranker=mem_reranker,
-        pref_mem=None,
+        pref_feedback=True,
     )
 
     return feedback_server, memory_manager, embedder

src/memos/api/handlers/__init__.py

@@ -32,7 +32,6 @@
 )
 from memos.api.handlers.formatters_handler import (
     format_memory_item,
-    post_process_pref_mem,
     to_iter,
 )
 
@@ -54,7 +53,6 @@
     "formatters_handler",
     "init_server",
     "memory_handler",
-    "post_process_pref_mem",
     "scheduler_handler",
     "search_handler",
     "suggestion_handler",

src/memos/api/handlers/add_handler.py

@@ -22,7 +22,7 @@ class AddHandler(BaseHandler):
     """
     Handler for memory addition operations.
 
-    Handles both text and preference memory additions with sync/async support.
+    Handles text memory additions with sync/async support.
     """
 
     def __init__(self, dependencies: HandlerDependencies):
@@ -41,7 +41,7 @@ def handle_add_memories(self, add_req: APIADDRequest) -> MemoryResponse:
         """
         Main handler for add memories endpoint.
 
-        Orchestrates the addition of both text and preference memories,
+        Orchestrates the addition of text memories,
         supporting concurrent processing.
 
         Args:

src/memos/api/handlers/component_init.py

@@ -19,11 +19,7 @@
     build_llm_config,
     build_mem_reader_config,
     build_nli_client_config,
-    build_pref_adder_config,
-    build_pref_extractor_config,
-    build_pref_retriever_config,
     build_reranker_config,
-    build_vec_db_config,
 )
 from memos.configs.mem_scheduler import SchedulerConfigFactory
 from memos.embedders.factory import EmbedderFactory
@@ -36,12 +32,6 @@
 from memos.mem_reader.factory import MemReaderFactory
 from memos.mem_scheduler.orm_modules.base_model import BaseDBManager
 from memos.mem_scheduler.scheduler_factory import SchedulerFactory
-from memos.memories.textual.prefer_text_memory.factory import (
-    AdderFactory,
-    ExtractorFactory,
-    RetrieverFactory,
-)
-from memos.memories.textual.simple_preference import SimplePreferenceTextMemory
 from memos.memories.textual.simple_tree import SimpleTreeTextMemory
 from memos.memories.textual.tree_text_memory.organize.history_manager import MemoryHistoryManager
 from memos.memories.textual.tree_text_memory.organize.manager import MemoryManager
@@ -56,7 +46,6 @@
     InternetRetrieverFactory,
 )
 from memos.reranker.factory import RerankerFactory
-from memos.vec_dbs.factory import VecDBFactory
 
 
 if TYPE_CHECKING:
@@ -125,7 +114,7 @@ def init_server() -> dict[str, Any]:
     required by the MemOS server, including:
     - Database connections (graph DB, vector DB)
     - Language models and embedders
-    - Memory systems (text, preference)
+    - Memory systems (text)
     - Scheduler and related modules
 
     Returns:
@@ -169,20 +158,11 @@ def init_server() -> dict[str, Any]:
     reranker_config = build_reranker_config()
     feedback_reranker_config = build_feedback_reranker_config()
     internet_retriever_config = build_internet_retriever_config()
-    vector_db_config = build_vec_db_config()
-    pref_extractor_config = build_pref_extractor_config()
-    pref_adder_config = build_pref_adder_config()
-    pref_retriever_config = build_pref_retriever_config()
 
     logger.debug("Component configurations built successfully")
 
     # Create component instances
     graph_db = GraphStoreFactory.from_config(graph_db_config)
-    vector_db = (
-        VecDBFactory.from_config(vector_db_config)
-        if os.getenv("ENABLE_PREFERENCE_MEMORY", "false") == "true"
-        else None
-    )
     llm = LLMFactory.from_config(llm_config)
     chat_llms = (
         _init_chat_llms(chat_llm_config)
@@ -231,61 +211,6 @@ def init_server() -> dict[str, Any]:
 
     logger.debug("Text memory initialized")
 
-    # Initialize preference memory components
-    pref_extractor = (
-        ExtractorFactory.from_config(
-            config_factory=pref_extractor_config,
-            llm_provider=llm,
-            embedder=embedder,
-            vector_db=vector_db,
-        )
-        if os.getenv("ENABLE_PREFERENCE_MEMORY", "false") == "true"
-        else None
-    )
-
-    pref_adder = (
-        AdderFactory.from_config(
-            config_factory=pref_adder_config,
-            llm_provider=llm,
-            embedder=embedder,
-            vector_db=vector_db,
-            text_mem=text_mem,
-        )
-        if os.getenv("ENABLE_PREFERENCE_MEMORY", "false") == "true"
-        else None
-    )
-
-    pref_retriever = (
-        RetrieverFactory.from_config(
-            config_factory=pref_retriever_config,
-            llm_provider=llm,
-            embedder=embedder,
-            reranker=feedback_reranker,
-            vector_db=vector_db,
-        )
-        if os.getenv("ENABLE_PREFERENCE_MEMORY", "false") == "true"
-        else None
-    )
-
-    logger.debug("Preference memory components initialized")
-
-    # Initialize preference memory
-    pref_mem = (
-        SimplePreferenceTextMemory(
-            extractor_llm=llm,
-            vector_db=vector_db,
-            embedder=embedder,
-            reranker=feedback_reranker,
-            extractor=pref_extractor,
-            adder=pref_adder,
-            retriever=pref_retriever,
-        )
-        if os.getenv("ENABLE_PREFERENCE_MEMORY", "false") == "true"
-        else None
-    )
-
-    logger.debug("Preference memory initialized")
-
     # Initialize MOS Server
     mos_server = MOSServer(
         mem_reader=mem_reader,
@@ -298,7 +223,6 @@ def init_server() -> dict[str, Any]:
     # Create MemCube with pre-initialized memory instances
     naive_mem_cube = NaiveMemCube(
         text_mem=text_mem,
-        pref_mem=pref_mem,
         act_mem=None,
         para_mem=None,
     )
@@ -325,7 +249,7 @@ def init_server() -> dict[str, Any]:
         mem_reader=mem_reader,
         searcher=searcher,
         reranker=feedback_reranker,
-        pref_mem=pref_mem,
+        pref_feedback=True,
     )
 
     # Initialize Scheduler
@@ -384,12 +308,7 @@ def init_server() -> dict[str, Any]:
         "naive_mem_cube": naive_mem_cube,
         "searcher": searcher,
         "api_module": api_module,
-        "vector_db": vector_db,
-        "pref_extractor": pref_extractor,
-        "pref_adder": pref_adder,
-        "pref_retriever": pref_retriever,
         "text_mem": text_mem,
-        "pref_mem": pref_mem,
         "online_bot": online_bot,
         "feedback_server": feedback_server,
         "redis_client": redis_client,

src/memos/api/handlers/formatters_handler.py

@@ -65,49 +65,14 @@ def format_memory_item(
     return memory
 
 
-def post_process_pref_mem(
-    memories_result: dict[str, Any],
-    pref_formatted_mem: list[dict[str, Any]],
-    mem_cube_id: str,
-    include_preference: bool,
-) -> dict[str, Any]:
-    """
-    Post-process preference memory results.
-
-    Adds formatted preference memories to the result dictionary and generates
-    instruction completion strings if preferences are included.
-
-    Args:
-        memories_result: Result dictionary to update
-        pref_formatted_mem: List of formatted preference memories
-        mem_cube_id: Memory cube ID
-        include_preference: Whether to include preferences in result
-
-    Returns:
-        Updated memories_result dictionary
-    """
-    if include_preference:
-        memories_result["pref_mem"].append(
-            {
-                "cube_id": mem_cube_id,
-                "memories": pref_formatted_mem,
-                "total_nodes": len(pref_formatted_mem),
-            }
-        )
-        pref_instruction, pref_note = instruct_completion(pref_formatted_mem)
-        memories_result["pref_string"] = pref_instruction
-        memories_result["pref_note"] = pref_note
-
-    return memories_result
-
-
 def post_process_textual_mem(
     memories_result: dict[str, Any],
     text_formatted_mem: list[dict[str, Any]],
     mem_cube_id: str,
 ) -> dict[str, Any]:
     """
-    Post-process text and tool memory results.
+    Post-process text, tool, skill and preference memory results.
+    Now automatically handles preference memories.
     """
     fact_mem = [
         mem
@@ -124,6 +89,11 @@ def post_process_textual_mem(
         mem for mem in text_formatted_mem if mem["metadata"]["memory_type"] == "SkillMemory"
     ]
 
+    # Extract preference memories
+    pref_mem = [
+        mem for mem in text_formatted_mem if mem["metadata"]["memory_type"] == "PreferenceMemory"
+    ]
+
     memories_result["text_mem"].append(
         {
             "cube_id": mem_cube_id,
@@ -145,6 +115,19 @@ def post_process_textual_mem(
             "total_nodes": len(skill_mem),
         }
     )
+
+    memories_result["pref_mem"].append(
+        {
+            "cube_id": mem_cube_id,
+            "memories": pref_mem,
+            "total_nodes": len(pref_mem),
+        }
+    )
+    if pref_mem:
+        pref_instruction, pref_note = instruct_completion(pref_mem)
+        memories_result["pref_string"] = pref_instruction
+        memories_result["pref_note"] = pref_note
+
     return memories_result