add user question cache (#640)

Author: IANTHEREAL

backend/app/rag/chat/chat_flow.py

@@ -105,9 +105,11 @@ def __init__(
                     user_id=self.user.id if self.user else None,
                     browser_id=self.browser_id,
                     origin=origin,
-                    visibility=ChatVisibility.PUBLIC
-                    if not self.user
-                    else ChatVisibility.PRIVATE,
+                    visibility=(
+                        ChatVisibility.PUBLIC
+                        if not self.user
+                        else ChatVisibility.PRIVATE
+                    ),
                 ),
             )
             chat_id = self.db_chat_obj.id
@@ -162,9 +164,9 @@ def chat(self) -> Generator[ChatEvent | str, None, None]:
         try:
             with self._trace_manager.observe(
                 trace_name="ChatFlow",
-                user_id=self.user.email
-                if self.user
-                else f"anonymous-{self.browser_id}",
+                user_id=(
+                    self.user.email if self.user else f"anonymous-{self.browser_id}"
+                ),
                 metadata={
                     "is_external_engine": self.engine_config.is_external_engine,
                     "chat_engine_config": self.engine_config.screenshot(),
@@ -259,7 +261,7 @@ def _chat_start(
             chat_message=DBChatMessage(
                 role=MessageRole.USER.value,
                 trace_url=self._trace_manager.trace_url,
-                content=self.user_question,
+                content=self.user_question.strip(),
             ),
         )
         db_assistant_message = chat_repo.create_message(
@@ -543,11 +545,13 @@ def _post_verification(
                         "external_request_id": external_request_id,
                         "qa_content": qa_content,
                     },
-                    headers={
-                        "Authorization": f"Bearer {post_verification_token}",
-                    }
-                    if post_verification_token
-                    else {},
+                    headers=(
+                        {
+                            "Authorization": f"Bearer {post_verification_token}",
+                        }
+                        if post_verification_token
+                        else {}
+                    ),
                     timeout=10,
                 )
                 resp.raise_for_status()
@@ -619,48 +623,65 @@ def _chat_finish(
     def _external_chat(self) -> Generator[ChatEvent | str, None, None]:
         db_user_message, db_assistant_message = yield from self._chat_start()
 
+        cache_messages = None
         goal, response_format = self.user_question, {}
-        try:
-            # 1. Generate the goal with the user question, knowledge graph and chat history.
-            goal, response_format = yield from self._generate_goal()
-
-            # 2. Check if the goal provided enough context information or need to clarify.
-            if self.engine_config.clarify_question:
-                need_clarify, need_clarify_response = yield from self._clarify_question(
-                    user_question=goal, chat_history=self.chat_history
+        if settings.ENABLE_QUESTION_CACHE and len(self.chat_history) == 0:
+            try:
+                logger.info(f"start to find_best_answer_for_question with question: {self.user_question}")
+                cache_messages = chat_repo.find_best_answer_for_question(
+                    self.db_session, self.user_question
                 )
-                if need_clarify:
-                    yield from self._chat_finish(
-                        db_assistant_message=db_assistant_message,
-                        db_user_message=db_user_message,
-                        response_text=need_clarify_response,
-                        annotation_silent=True,
-                    )
-                    return
-        except Exception as e:
-            goal = self.user_question
-            logger.warning(
-                f"Failed to generate refined goal, fallback to use user question as goal directly: {e}",
-                exc_info=True,
-                extra={},
-            )
+                if cache_messages and len(cache_messages) > 0:
+                    logger.info(f"find_best_answer_for_question result {len(cache_messages)} for question {self.user_question}")
+            except Exception as e:
+                logger.error(f"Failed to find best answer for question {self.user_question}: {e}")
 
-        cache_messages = None
-        if settings.ENABLE_QUESTION_CACHE:
+        if not cache_messages or len(cache_messages) == 0:
             try:
-                logger.info(
-                    f"start to find_recent_assistant_messages_by_goal with goal: {goal}, response_format: {response_format}"
-                )
-                cache_messages = chat_repo.find_recent_assistant_messages_by_goal(
-                    self.db_session,
-                    {"goal": goal, "Lang": response_format.get("Lang", "English")},
-                    90,
-                )
-                logger.info(
-                    f"find_recent_assistant_messages_by_goal result {len(cache_messages)} for goal {goal}"
-                )
+                # 1. Generate the goal with the user question, knowledge graph and chat history.
+                goal, response_format = yield from self._generate_goal()
+
+                # 2. Check if the goal provided enough context information or need to clarify.
+                if self.engine_config.clarify_question:
+                    need_clarify, need_clarify_response = (
+                        yield from self._clarify_question(
+                            user_question=goal, chat_history=self.chat_history
+                        )
+                    )
+                    if need_clarify:
+                        yield from self._chat_finish(
+                            db_assistant_message=db_assistant_message,
+                            db_user_message=db_user_message,
+                            response_text=need_clarify_response,
+                            annotation_silent=True,
+                        )
+                        return
             except Exception as e:
-                logger.error(f"Failed to find recent assistant messages by goal: {e}")
+                goal = self.user_question
+                logger.warning(
+                    f"Failed to generate refined goal, fallback to use user question as goal directly: {e}",
+                    exc_info=True,
+                    extra={},
+                )
+
+            cache_messages = None
+            if settings.ENABLE_QUESTION_CACHE:
+                try:
+                    logger.info(
+                        f"start to find_recent_assistant_messages_by_goal with goal: {goal}, response_format: {response_format}"
+                    )
+                    cache_messages = chat_repo.find_recent_assistant_messages_by_goal(
+                        self.db_session,
+                        {"goal": goal, "Lang": response_format.get("Lang", "English")},
+                        90,
+                    )
+                    logger.info(
+                        f"find_recent_assistant_messages_by_goal result {len(cache_messages)} for goal {goal}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Failed to find recent assistant messages by goal: {e}"
+                    )
 
         stream_chat_api_url = (
             self.engine_config.external_engine_config.stream_chat_api_url

backend/app/repositories/chat.py

@@ -187,6 +187,63 @@ def find_recent_assistant_messages_by_goal(
 
         return session.exec(query).all()
 
+    def find_best_answer_for_question(
+        self, session: Session, user_question: str
+    ) -> List[ChatMessage]:
+        """Find best answer messages for a specific user question.
+
+        This method finds assistant messages that:
+        1. Are marked as best answers
+        2. Are responses (ordinal=2) to the exact user question
+        3. Were created within the last 15 days
+
+        Args:
+            session: Database session
+            user_question: The exact question text to search for
+
+        Returns:
+            List of matching assistant messages marked as best answers
+        """
+        cutoff = datetime.now(UTC) - timedelta(days=15)
+
+        # First, get all best answers from assistant (using the is_best_answer index)
+        best_answer_chat_ids = (
+            select(ChatMessage.chat_id)
+            .where(
+                ChatMessage.is_best_answer == 1,  # Using the index for efficiency
+                ChatMessage.role == "assistant",
+                ChatMessage.ordinal == 2,
+                ChatMessage.created_at >= cutoff
+            )
+        )
+
+        # Then, find user questions that match our target question and belong to chats with best answers
+        matching_chat_ids = (
+            select(ChatMessage.chat_id)
+            .where(
+                ChatMessage.chat_id.in_(best_answer_chat_ids),
+                ChatMessage.role == "user",
+                ChatMessage.ordinal == 1,
+                ChatMessage.content == user_question.strip()
+            )
+        )
+
+        # Finally, get the best answers that correspond to the matching user questions
+        query = (
+            select(ChatMessage)
+            .where(
+                ChatMessage.is_best_answer == 1,
+                ChatMessage.role == "assistant",
+                ChatMessage.ordinal == 2,
+                ChatMessage.chat_id.in_(matching_chat_ids)
+            )
+        )
+
+        query = query.order_by(desc(ChatMessage.created_at))
+
+        # Execute the query and return all results
+        return session.exec(query).all()
+
     def chat_trend_by_user(
         self, session: Session, start_date: date, end_date: date
     ) -> List[dict]: