Feat/optimize cloud service api

src/memos/api/handlers/memory_handler.py

@@ -246,22 +246,17 @@ def handle_delete_memories(delete_mem_req: DeleteMemoryRequest, naive_mem_cube:
 
     try:
         if delete_mem_req.memory_ids is not None:
-            for cube_id in delete_mem_req.writable_cube_ids:
-                naive_mem_cube.text_mem.delete(delete_mem_req.memory_ids, user_name=cube_id)
+            naive_mem_cube.text_mem.delete_by_memory_ids(delete_mem_req.memory_ids)
             if naive_mem_cube.pref_mem is not None:
                 naive_mem_cube.pref_mem.delete(delete_mem_req.memory_ids)
         elif delete_mem_req.file_ids is not None:
             naive_mem_cube.text_mem.delete_by_filter(
                 writable_cube_ids=delete_mem_req.writable_cube_ids, file_ids=delete_mem_req.file_ids
             )
         elif delete_mem_req.filter is not None:
-            # TODO: Implement deletion by filter
-            # Need to find memories matching filter and delete them
-            logger.warning("Deletion by filter not implemented yet")
-            return DeleteMemoryResponse(
-                message="Deletion by filter not implemented yet",
-                data={"status": "failure"},
-            )
+            naive_mem_cube.text_mem.delete_by_filter(filter=delete_mem_req.filter)
+            if naive_mem_cube.pref_mem is not None:
+                naive_mem_cube.pref_mem.delete_by_filter(filter=delete_mem_req.filter)
     except Exception as e:
         logger.error(f"Failed to delete memories: {e}", exc_info=True)
         return DeleteMemoryResponse(

src/memos/api/product_models.py

@@ -784,7 +784,7 @@ class GetMemoryRequest(BaseRequest):
 class DeleteMemoryRequest(BaseRequest):
     """Request model for deleting memories."""
 
-    writable_cube_ids: list[str] = Field(..., description="Writable cube IDs")
+    writable_cube_ids: list[str] = Field(None, description="Writable cube IDs")
     memory_ids: list[str] | None = Field(None, description="Memory IDs")
     file_ids: list[str] | None = Field(None, description="File IDs")
     filter: dict[str, Any] | None = Field(None, description="Filter for the memory")

src/memos/api/routers/server_router.py

@@ -340,7 +340,7 @@ def feedback_memories(feedback_req: APIFeedbackRequest):
 # =============================================================================
 
 
-@router.get(
+@router.post(
     "/get_user_names_by_memory_ids",
     summary="Get user names by memory ids",
     response_model=GetUserNamesByMemoryIdsResponse,

src/memos/memories/textual/preference.py

@@ -314,6 +314,15 @@ def delete(self, memory_ids: list[str]) -> None:
         for collection_name in collection_list:
             self.vector_db.delete(collection_name, memory_ids)
 
+    def delete_by_filter(self, filter: dict[str, Any]) -> None:
+        """Delete memories by filter.
+        Args:
+            filter (dict[str, Any]): Filter criteria.
+        """
+        collection_list = self.vector_db.config.collection_name
+        for collection_name in collection_list:
+            self.vector_db.delete_by_filter(collection_name=collection_name, filter=filter)
+
     def delete_with_collection_name(self, collection_name: str, memory_ids: list[str]) -> None:
         """Delete memories by their IDs and collection name.
         Args:

src/memos/memories/textual/tree.py

@@ -347,6 +347,13 @@ def delete(self, memory_ids: list[str], user_name: str | None = None) -> None:
             except Exception as e:
                 logger.warning(f"TreeTextMemory.delete_hard: failed to delete {mid}: {e}")
 
+    def delete_by_memory_ids(self, memory_ids: list[str]) -> None:
+        """Delete memories by memory_ids."""
+        try:
+            self.graph_store.delete_node_by_prams(memory_ids=memory_ids)
+        except Exception as e:
+            logger.error(f"An error occurred while deleting memories by memory_ids: {e}")
+
     def delete_all(self) -> None:
         """Delete all memories and their relationships from the graph store."""
         try:
@@ -358,7 +365,7 @@ def delete_all(self) -> None:
 
     def delete_by_filter(
         self,
-        writable_cube_ids: list[str],
+        writable_cube_ids: list[str] | None = None,
         file_ids: list[str] | None = None,
         filter: dict | None = None,
     ) -> None:

src/memos/vec_dbs/milvus.py

@@ -646,3 +646,11 @@ def delete(self, collection_name: str, ids: list[str]) -> None:
             collection_name=collection_name,
             ids=ids,
         )
+
+    def delete_by_filter(self, collection_name: str, filter: dict[str, Any]) -> None:
+        """Delete items from the vector database by filter."""
+        expr = self._dict_to_expr(filter) if filter else ""
+        self.client.delete(
+            collection_name=collection_name,
+            filter=expr,
+        )