feat: Feedback Function

src/memos/api/handlers/add_handler.py

@@ -5,6 +5,8 @@
 using dependency injection for better modularity and testability.
 """
 
+from pydantic import validate_call
+
 from memos.api.handlers.base_handler import BaseHandler, HandlerDependencies
 from memos.api.product_models import APIADDRequest, APIFeedbackRequest, MemoryResponse
 from memos.memories.textual.item import (
@@ -13,6 +15,7 @@
 from memos.multi_mem_cube.composite_cube import CompositeCubeView
 from memos.multi_mem_cube.single_cube import SingleCubeView
 from memos.multi_mem_cube.views import MemCubeView
+from memos.types import MessageList
 
 
 class AddHandler(BaseHandler):
@@ -60,38 +63,45 @@ def handle_add_memories(self, add_req: APIADDRequest) -> MemoryResponse:
 
         cube_view = self._build_cube_view(add_req)
 
+        @validate_call
+        def _check_messages(messages: MessageList) -> None:
+            pass
+
         if add_req.is_feedback:
-            chat_history = add_req.chat_history
-            messages = add_req.messages
-            if chat_history is None:
-                chat_history = []
-            if messages is None:
-                messages = []
-            concatenate_chat = chat_history + messages
-
-            last_user_index = max(i for i, d in enumerate(concatenate_chat) if d["role"] == "user")
-            feedback_content = concatenate_chat[last_user_index]["content"]
-            feedback_history = concatenate_chat[:last_user_index]
-
-            feedback_req = APIFeedbackRequest(
-                user_id=add_req.user_id,
-                session_id=add_req.session_id,
-                task_id=add_req.task_id,
-                history=feedback_history,
-                feedback_content=feedback_content,
-                writable_cube_ids=add_req.writable_cube_ids,
-                async_mode=add_req.async_mode,
-            )
-            process_record = cube_view.feedback_memories(feedback_req)
+            try:
+                messages = add_req.messages
+                _check_messages(messages)
 
-            self.logger.info(
-                f"[FeedbackHandler] Final feedback results count={len(process_record)}"
-            )
+                chat_history = add_req.chat_history if add_req.chat_history else []
+                concatenate_chat = chat_history + messages
 
-            return MemoryResponse(
-                message="Memory feedback successfully",
-                data=[process_record],
-            )
+                last_user_index = max(
+                    i for i, d in enumerate(concatenate_chat) if d["role"] == "user"
+                )
+                feedback_content = concatenate_chat[last_user_index]["content"]
+                feedback_history = concatenate_chat[:last_user_index]
+
+                feedback_req = APIFeedbackRequest(
+                    user_id=add_req.user_id,
+                    session_id=add_req.session_id,
+                    task_id=add_req.task_id,
+                    history=feedback_history,
+                    feedback_content=feedback_content,
+                    writable_cube_ids=add_req.writable_cube_ids,
+                    async_mode=add_req.async_mode,
+                )
+                process_record = cube_view.feedback_memories(feedback_req)
+
+                self.logger.info(
+                    f"[ADDFeedbackHandler] Final feedback results count={len(process_record)}"
+                )
+
+                return MemoryResponse(
+                    message="Memory feedback successfully",
+                    data=[process_record],
+                )
+            except Exception as e:
+                self.logger.warning(f"[ADDFeedbackHandler] Running error: {e}")
 
         results = cube_view.add_memories(add_req)
 

src/memos/api/product_models.py

@@ -642,15 +642,14 @@ class APIFeedbackRequest(BaseRequest):
     )
     feedback_content: str | None = Field(..., description="Feedback content to process")
     feedback_time: str | None = Field(None, description="Feedback time")
-    # ==== Multi-cube writing ====
     writable_cube_ids: list[str] | None = Field(
         None, description="List of cube IDs user can write for multi-cube add"
     )
     async_mode: Literal["sync", "async"] = Field(
         "async", description="feedback mode: sync or async"
     )
     corrected_answer: bool = Field(False, description="Whether need return corrected answer")
-    # ==== Backward compatibility ====
+    # ==== mem_cube_id is NOT enabled====
     mem_cube_id: str | None = Field(
         None,
         description=(

src/memos/graph_dbs/polardb.py

@@ -1455,6 +1455,98 @@ def get_context_chain(self, id: str, type: str = "FOLLOWS") -> list[str]:
         """Get the ordered context chain starting from a node."""
         raise NotImplementedError
 
+    @timed
+    def seach_by_keywords(
+        self,
+        query_words: list[str],
+        scope: str | None = None,
+        status: str | None = None,
+        search_filter: dict | None = None,
+        user_name: str | None = None,
+        filter: dict | None = None,
+        knowledgebase_ids: list[str] | None = None,
+        tsvector_field: str = "properties_tsvector_zh",
+        tsquery_config: str = "jiebaqry",
+        **kwargs,
+    ) -> list[dict]:
+        where_clauses = []
+
+        if scope:
+            where_clauses.append(
+                f"ag_catalog.agtype_access_operator(properties, '\"memory_type\"'::agtype) = '\"{scope}\"'::agtype"
+            )
+        if status:
+            where_clauses.append(
+                f"ag_catalog.agtype_access_operator(properties, '\"status\"'::agtype) = '\"{status}\"'::agtype"
+            )
+        else:
+            where_clauses.append(
+                "ag_catalog.agtype_access_operator(properties, '\"status\"'::agtype) = '\"activated\"'::agtype"
+            )
+
+        # Build user_name filter with knowledgebase_ids support (OR relationship) using common method
+        user_name_conditions = self._build_user_name_and_kb_ids_conditions_sql(
+            user_name=user_name,
+            knowledgebase_ids=knowledgebase_ids,
+            default_user_name=self.config.user_name,
+        )
+
+        # Add OR condition if we have any user_name conditions
+        if user_name_conditions:
+            if len(user_name_conditions) == 1:
+                where_clauses.append(user_name_conditions[0])
+            else:
+                where_clauses.append(f"({' OR '.join(user_name_conditions)})")
+
+        # Add search_filter conditions
+        if search_filter:
+            for key, value in search_filter.items():
+                if isinstance(value, str):
+                    where_clauses.append(
+                        f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype) = '\"{value}\"'::agtype"
+                    )
+                else:
+                    where_clauses.append(
+                        f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype) = {value}::agtype"
+                    )
+
+        # Build filter conditions using common method
+        filter_conditions = self._build_filter_conditions_sql(filter)
+        where_clauses.extend(filter_conditions)
+        # Add fulltext search condition
+        # Convert query_text to OR query format: "word1 | word2 | word3"
+        tsquery_string = " | ".join(query_words)
+
+        where_clauses.append(f"{tsvector_field} @@ to_tsquery('{tsquery_config}', %s)")
+
+        where_clause = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
+
+        # Build fulltext search query
+        query = f"""
+            SELECT
+                ag_catalog.agtype_access_operator(properties, '"id"'::agtype) AS old_id,
+                agtype_object_field_text(properties, 'memory') as memory_text
+            FROM "{self.db_name}_graph"."Memory"
+            {where_clause}
+        """
+
+        params = (tsquery_string,)
+        logger.info(f"[search_by_fulltext] query: {query}, params: {params}")
+        conn = self._get_connection()
+        try:
+            with conn.cursor() as cursor:
+                cursor.execute(query, params)
+                results = cursor.fetchall()
+                output = []
+                for row in results:
+                    oldid = row[0]
+                    id_val = str(oldid)
+                    output.append({"id": id_val})
+
+                return output
+        finally:
+            self._return_connection(conn)
+
     @timed
     def search_by_fulltext(
         self,