reme-ai 0.1.0__py3-none-any.whl

reme_ai/summary/personal/get_observation_op.py

@@ -0,0 +1,147 @@
+import re
+from typing import List
+
+from flowllm import C, BaseLLMOp
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.schema.memory import BaseMemory, PersonalMemory
+from reme_ai.utils.datetime_handler import DatetimeHandler
+
+
+@C.register_op()
+class GetObservationOp(BaseLLMOp):
+    """
+    A specialized operation class to generate observations from chat messages using BaseLLMOp.
+    """
+    file_path: str = __file__
+
+    def execute(self):
+        """Extract personal observations from chat messages"""
+        # Get messages from context - guaranteed to exist by flow input
+        messages: List[Message] = self.context.messages
+        if not messages:
+            logger.warning("No messages found in context")
+            return
+
+        # Filter messages - exclude those with time-related keywords
+        filtered_messages = self._filter_messages(messages)
+        if not filtered_messages:
+            logger.warning("No messages left after filtering")
+            self.context.observation_memories = []
+            return
+
+        logger.info(f"Extracting observations from {len(filtered_messages)} filtered messages")
+
+        # Extract observations using LLM
+        observation_memories = self._extract_observations_from_messages(filtered_messages)
+
+        # Store results in context using standardized key
+        self.context.observation_memories = observation_memories
+        logger.info(f"Generated {len(observation_memories)} observation memories")
+
+    def _filter_messages(self, messages: List[Message]) -> List[Message]:
+        """
+        Filters the chat messages to exclude those containing time-related keywords.
+
+        Args:
+            messages: List of messages to filter
+
+        Returns:
+            List[Message]: A list of filtered messages without time keywords.
+        """
+        filtered_messages = []
+        for msg in messages:
+            if not DatetimeHandler.has_time_word(query=msg.content, language=self.language):
+                filtered_messages.append(msg)
+
+        logger.info(f"Filtered messages from {len(messages)} to {len(filtered_messages)}")
+        return filtered_messages
+
+    def _extract_observations_from_messages(self, filtered_messages: List[Message]) -> List[BaseMemory]:
+        """Extract observations from filtered messages using LLM"""
+        user_name = self.context.get("user_name", "user")
+
+        # Build prompt for observation extraction
+        user_query_list = []
+        for i, msg in enumerate(filtered_messages):
+            user_query_list.append(f"{i + 1} {user_name}: {msg.content}")
+
+        # Create prompt using the prompt format method
+        system_prompt = self.prompt_format(prompt_name="get_observation_system",
+                                           num_obs=len(user_query_list),
+                                           user_name=user_name)
+        few_shot = self.prompt_format(prompt_name="get_observation_few_shot", user_name=user_name)
+        user_query = self.prompt_format(prompt_name="get_observation_user_query",
+                                        user_query="\n".join(user_query_list),
+                                        user_name=user_name)
+
+        full_prompt = f"{system_prompt}\n\n{few_shot}\n\n{user_query}"
+        logger.info(f"get_observation_prompt={full_prompt}")
+
+        def parse_observations(message: Message) -> List[BaseMemory]:
+            """Parse LLM response and create observation memories"""
+            response_text = message.content
+            logger.info(f"get_observation_response={response_text}")
+
+            # Parse observations using class method
+            parsed_observations = GetObservationOp.parse_observation_response(response_text)
+
+            observation_memories = []
+            for obs in parsed_observations:
+                idx = obs["index"] - 1  # Convert to 0-based index
+                if idx >= len(filtered_messages):
+                    logger.warning(f"Invalid index {idx} for messages list of length {len(filtered_messages)}")
+                    continue
+
+                # Create observation memory
+                observation = PersonalMemory(
+                    workspace_id=self.context.workspace_id,
+                    when_to_use=obs["keywords"],
+                    content=obs["content"],
+                    target=user_name,
+                    author=self.llm.model_name,
+                    metadata={
+                        "keywords": obs["keywords"],
+                        "source_message": filtered_messages[idx].content,
+                        "observation_type": "personal_info"
+                    }
+                )
+                observation_memories.append(observation)
+                logger.info(f"Created observation: {obs['content'][:50]}...")
+
+            return observation_memories
+
+        # Use LLM chat with callback function
+        return self.llm.chat(messages=[Message(content=full_prompt)], callback_fn=parse_observations)
+
+    @staticmethod
+    def parse_observation_response(response_text: str) -> List[dict]:
+        """Parse observation response to extract structured data"""
+        # Pattern to match both Chinese and English observation formats
+        pattern = r"信息：<(\d+)>\s*<>\s*<([^<>]+)>\s*<([^<>]*)>|Information:\s*<(\d+)>\s*<>\s*<([^<>]+)>\s*<([^<>]*)>"
+        matches = re.findall(pattern, response_text, re.IGNORECASE | re.MULTILINE)
+
+        observations = []
+        for match in matches:
+            # Handle both Chinese and English patterns
+            if match[0]:  # Chinese pattern
+                idx_str, content, keywords = match[0], match[1], match[2]
+            else:  # English pattern  
+                idx_str, content, keywords = match[3], match[4], match[5]
+
+            try:
+                idx = int(idx_str)
+                # Skip if content indicates no meaningful observation
+                content_lower = content.lower().strip()
+                if content_lower not in ['无', 'none', '', 'repeat']:
+                    observations.append({
+                        "index": idx,
+                        "content": content.strip(),
+                        "keywords": keywords.strip() if keywords else ""
+                    })
+            except ValueError:
+                logger.warning(f"Invalid index format: {idx_str}")
+                continue
+
+        return observations

reme_ai/summary/personal/get_observation_with_time_op.py

@@ -0,0 +1,165 @@
+import re
+from typing import List
+
+from flowllm import C, BaseLLMOp
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.schema.memory import BaseMemory, PersonalMemory
+from reme_ai.utils.datetime_handler import DatetimeHandler
+
+
+@C.register_op()
+class GetObservationWithTimeOp(BaseLLMOp):
+    """
+    A specialized operation class to extract observations with time information from chat messages using BaseLLMOp.
+    """
+    file_path: str = __file__
+
+    def execute(self):
+        """Extract personal observations with time information from chat messages"""
+        # Get messages from context - guaranteed to exist by flow input
+        messages: List[Message] = self.context.messages
+        if not messages:
+            logger.warning("No messages found in context")
+            return
+
+        # Filter messages - only include those with time-related keywords
+        filtered_messages = self._filter_messages(messages)
+        if not filtered_messages:
+            logger.warning("No messages with time keywords found")
+            self.context.observation_memories_with_time = []
+            return
+
+        logger.info(f"Extracting observations with time from {len(filtered_messages)} filtered messages")
+
+        # Extract observations using LLM
+        observation_memories_with_time = self._extract_observations_with_time_from_messages(filtered_messages)
+
+        # Store results in context using standardized key
+        self.context.observation_memories_with_time = observation_memories_with_time
+        logger.info(f"Generated {len(observation_memories_with_time)} observation memories with time")
+
+    def _filter_messages(self, messages: List[Message]) -> List[Message]:
+        """
+        Filters the chat messages to only include those containing time-related keywords.
+
+        Args:
+            messages: List of messages to filter
+
+        Returns:
+            List[Message]: A list of filtered messages that mention time.
+        """
+        filtered_messages = []
+        for msg in messages:
+            if DatetimeHandler.has_time_word(query=msg.content, language=self.language):
+                filtered_messages.append(msg)
+
+        logger.info(f"Filtered messages from {len(messages)} to {len(filtered_messages)}")
+        return filtered_messages
+
+    def _extract_observations_with_time_from_messages(self, filtered_messages: List[Message]) -> List[BaseMemory]:
+        """Extract observations with time information from filtered messages using LLM"""
+        user_name = self.context.get("user_name", "user")
+
+        # Build prompt for observation extraction with time
+        user_query_list = []
+        for i, msg in enumerate(filtered_messages):
+            # Create a DatetimeHandler instance for each message's timestamp and format it
+            dt_handler = DatetimeHandler(dt=msg.time_created)
+
+            # Get time format from prompt configuration
+            time_format = self.prompt_format(prompt_name="time_string_format")
+            dt = dt_handler.string_format(string_format=time_format, language=self.language)
+
+            # Append formatted timestamp-query pairs to the user_query_list
+            colon = self._get_colon_word()
+            user_query_list.append(f"{i + 1} {dt} {user_name}{colon}{msg.content}")
+
+        # Create prompt using the prompt format method
+        system_prompt = self.prompt_format(prompt_name="get_observation_with_time_system",
+                                           num_obs=len(user_query_list),
+                                           user_name=user_name)
+        few_shot = self.prompt_format(prompt_name="get_observation_with_time_few_shot", user_name=user_name)
+        user_query = self.prompt_format(prompt_name="get_observation_with_time_user_query",
+                                        user_query="\n".join(user_query_list),
+                                        user_name=user_name)
+
+        full_prompt = f"{system_prompt}\n\n{few_shot}\n\n{user_query}"
+        logger.info(f"get_observation_with_time_prompt={full_prompt}")
+
+        def parse_observations(message: Message) -> List[BaseMemory]:
+            """Parse LLM response and create observation memories with time"""
+            response_text = message.content
+            logger.info(f"get_observation_with_time_response={response_text}")
+
+            # Parse observations using class method
+            parsed_observations = GetObservationWithTimeOp.parse_observation_with_time_response(response_text)
+
+            observation_memories = []
+            for obs in parsed_observations:
+                idx = obs["index"] - 1  # Convert to 0-based index
+                if idx >= len(filtered_messages):
+                    logger.warning(f"Invalid index {idx} for messages list of length {len(filtered_messages)}")
+                    continue
+
+                # Create observation memory
+                observation = PersonalMemory(
+                    workspace_id=self.context.workspace_id,
+                    when_to_use=obs["keywords"],
+                    content=obs["content"],
+                    target=user_name,
+                    author=getattr(self.llm, "model_name", "system"),
+                    metadata={
+                        "keywords": obs["keywords"],
+                        "time_info": obs.get("time_info", ""),
+                        "source_message": filtered_messages[idx].content,
+                        "observation_type": "personal_info_with_time"
+                    }
+                )
+                observation_memories.append(observation)
+                logger.info(f"Created observation with time: {obs['content'][:50]}...")
+
+            return observation_memories
+
+        # Use LLM chat with callback function
+        return self.llm.chat(messages=[Message(content=full_prompt)], callback_fn=parse_observations)
+
+    def _get_colon_word(self) -> str:
+        """Get language-specific colon word"""
+        colon_dict = {"zh": "：", "cn": "：", "en": ": "}
+        return colon_dict.get(self.language, ": ")
+
+    @staticmethod
+    def parse_observation_with_time_response(response_text: str) -> List[dict]:
+        """Parse observation with time response to extract structured data"""
+        # Pattern to match both Chinese and English observation formats with time information
+        # Chinese: 信息：<1> <时间信息或不输出> <明确的重要信息或"无"> <关键词>
+        # English: Information: <1> <Time information or do not output> <Clear important information or "None"> <Keywords>
+        pattern = r"信息：<(\d+)>\s*<([^<>]*)>\s*<([^<>]+)>\s*<([^<>]*)>|Information:\s*<(\d+)>\s*<([^<>]*)>\s*<([^<>]+)>\s*<([^<>]*)>"
+        matches = re.findall(pattern, response_text, re.IGNORECASE | re.MULTILINE)
+
+        observations = []
+        for match in matches:
+            # Handle both Chinese and English patterns
+            if match[0]:  # Chinese pattern
+                idx_str, time_info, content, keywords = match[0], match[1], match[2], match[3]
+            else:  # English pattern  
+                idx_str, time_info, content, keywords = match[4], match[5], match[6], match[7]
+
+            try:
+                idx = int(idx_str)
+                # Skip if content indicates no meaningful observation
+                content_lower = content.lower().strip()
+                if content_lower not in ['无', 'none', '', 'repeat']:
+                    observations.append({
+                        "index": idx,
+                        "time_info": time_info.strip() if time_info else "",
+                        "content": content.strip(),
+                        "keywords": keywords.strip() if keywords else ""
+                    })
+            except ValueError:
+                logger.warning(f"Invalid index format: {idx_str}")
+                continue
+
+        return observations

reme_ai/summary/personal/get_reflection_subject_op.py

@@ -0,0 +1,179 @@
+from typing import List
+
+from flowllm import C, BaseLLMOp
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.schema.memory import BaseMemory, PersonalMemory
+
+
+@C.register_op()
+class GetReflectionSubjectOp(BaseLLMOp):
+    """
+    A specialized operation class responsible for retrieving unreflected memory nodes,
+    generating reflection prompts with current insights, invoking an LLM for fresh insights,
+    parsing the LLM responses, forming new insight nodes, and updating memory statuses accordingly.
+    """
+    file_path: str = __file__
+
+    def new_insight_memory(self, insight_content: str, target: str) -> PersonalMemory:
+        """
+        Creates a new PersonalMemory for an insight with the given content.
+
+        Args:
+            insight_content (str): The content of the insight.
+            target (str): The target person the insight is about.
+
+        Returns:
+            PersonalMemory: A new PersonalMemory instance representing the insight.
+        """
+        return PersonalMemory(
+            workspace_id=self.context.get("workspace_id", ""),
+            content=insight_content,
+            target=target,
+            reflection_subject=insight_content,  # Store the subject in the dedicated field
+            author=getattr(self.llm, "model_name", "system"),
+            metadata={
+                "insight_type": "reflection_subject",
+                "memory_type": "personal_topic"
+            }
+        )
+
+    def execute(self):
+        """
+        Generate reflection subjects (topics) from personal memories for insight extraction.
+
+        Process:
+        1. Retrieve personal memories and existing insights from context
+        2. Check if sufficient memories exist for reflection
+        3. Generate new reflection subjects using LLM
+        4. Create insight memory objects for new subjects
+        5. Store results in context for next operation
+        """
+        # Get memories from previous operation
+        personal_memories = self.context.response.metadata.get("personal_memories", [])
+        existing_insights = self.context.response.metadata.get("existing_insights", [])
+
+        # Get operation parameters
+        reflect_obs_cnt_threshold = self.op_params.get("reflect_obs_cnt_threshold", 10)
+        reflect_num_questions = self.op_params.get("reflect_num_questions", 3)
+        user_name = self.context.get("user_name", "user")
+
+        # Validate sufficient memories for reflection
+        if len(personal_memories) < reflect_obs_cnt_threshold:
+            logger.info(f"Insufficient memories for reflection: {len(personal_memories)} < {reflect_obs_cnt_threshold}")
+            self.context.response.metadata["insight_memories"] = []
+            return
+
+        # Extract existing insight subjects to avoid duplication
+        existing_subjects = []
+        if existing_insights:
+            existing_subjects = [memory.content for memory in existing_insights if
+                                 hasattr(memory, 'content') and memory.content]
+
+        logger.info(f"Found {len(existing_subjects)} existing insight subjects")
+
+        # Prepare memory content for LLM analysis
+        memory_contents = []
+        for memory in personal_memories:
+            if hasattr(memory, 'content') and memory.content.strip():
+                memory_contents.append(memory.content.strip())
+
+        if not memory_contents:
+            logger.warning("No valid memory content found for reflection")
+            self.context.response.metadata["insight_memories"] = []
+            return
+
+        # Generate reflection subjects using LLM
+        insight_memories = self._generate_reflection_subjects(
+            memory_contents, existing_subjects, user_name, reflect_num_questions
+        )
+
+        # Store results in context
+        self.context.response.metadata["insight_memories"] = insight_memories
+        logger.info(f"Generated {len(insight_memories)} new reflection subject memories")
+
+    def _generate_reflection_subjects(self, memory_contents: List[str], existing_subjects: List[str],
+                                      user_name: str, num_questions: int) -> List[BaseMemory]:
+        """
+        Generate new reflection subjects using LLM analysis of memory contents.
+        
+        Args:
+            memory_contents: List of memory content strings
+            existing_subjects: List of already existing subject strings
+            user_name: Target username
+            num_questions: Maximum number of new subjects to generate
+            
+        Returns:
+            List of PersonalMemory objects representing new reflection subjects
+        """
+        # Build LLM prompt
+        system_prompt = self.prompt_format(
+            prompt_name="get_reflection_subject_system",
+            user_name=user_name,
+            num_questions=num_questions
+        )
+        few_shot = self.prompt_format(
+            prompt_name="get_reflection_subject_few_shot",
+            user_name=user_name
+        )
+        user_query = self.prompt_format(
+            prompt_name="get_reflection_subject_user_query",
+            user_name=user_name,
+            exist_keys=", ".join(existing_subjects) if existing_subjects else "None",
+            user_query="\n".join(memory_contents)
+        )
+
+        full_prompt = f"{system_prompt}\n\n{few_shot}\n\n{user_query}"
+        logger.info(f"Reflection subject prompt length: {len(full_prompt)} chars")
+
+        def parse_reflection_response(message: Message) -> List[BaseMemory]:
+            """Parse LLM response and create insight memories"""
+            response_text = message.content
+            logger.info(f"Reflection subjects response: {response_text}")
+
+            # Parse new subjects using class method
+            new_subjects = GetReflectionSubjectOp.parse_reflection_subjects_response(response_text, existing_subjects)
+
+            # Create insight memory objects
+            insight_memories = []
+            for subject in new_subjects:
+                insight_memory = self.new_insight_memory(
+                    insight_content=subject,
+                    target=user_name
+                )
+                insight_memories.append(insight_memory)
+                logger.info(f"Created reflection subject: {subject}")
+
+            return insight_memories
+
+        # Generate subjects using LLM
+        return self.llm.chat(messages=[Message(content=full_prompt)], callback_fn=parse_reflection_response)
+
+    def get_language_value(self, value_dict: dict):
+        """Get language-specific value from dictionary"""
+        return value_dict.get(self.language, value_dict.get("en"))
+
+    @staticmethod
+    def parse_reflection_subjects_response(response_text: str, existing_subjects: List[str] = None) -> List[str]:
+        """Parse reflection subjects response to extract new subject attributes"""
+        if existing_subjects is None:
+            existing_subjects = []
+
+        # Split response into lines and clean up
+        lines = response_text.strip().split('\n')
+        subjects = []
+
+        for line in lines:
+            line = line.strip()
+            # Skip empty lines, "None" responses, and existing subjects
+            if (line and
+                    line not in ['无', 'None', ''] and
+                    line not in existing_subjects and
+                    not line.startswith('新增') and  # Skip Chinese header
+                    not line.startswith('New ') and  # Skip English header
+                    len(line) > 1):  # Skip single character responses
+                subjects.append(line)
+
+        logger.info(f"Parsed {len(subjects)} new reflection subjects from response")
+        return subjects

reme_ai/summary/personal/info_filter_op.py

@@ -0,0 +1,177 @@
+import re
+from typing import List
+
+from flowllm import C, BaseLLMOp
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.schema.memory import PersonalMemory
+
+
+@C.register_op()
+class InfoFilterOp(BaseLLMOp):
+    """
+    A specialized operation class to filter messages based on information content scores using BaseLLMOp.
+    This filters chat messages by retaining only those that include significant information about the user.
+    """
+    file_path: str = __file__
+
+    def execute(self):
+        """Filter messages based on information content scores"""
+        # Get messages from context - guaranteed to exist by flow input
+        self.context.messages = [Message(**x) if isinstance(x, dict) else x for x in self.context.messages]
+        messages: List[Message] = self.context.messages
+        if not messages:
+            logger.warning("No messages found in context")
+            return
+
+        # Get operation parameters
+        preserved_scores = self.op_params.get("preserved_scores", "2,3")
+        info_filter_msg_max_size = self.op_params.get("info_filter_msg_max_size", 200)
+        user_name = self.context.get("user_name", "user")
+
+        # Filter and process messages
+        info_messages = self._filter_and_process_messages(messages, user_name, info_filter_msg_max_size)
+        if not info_messages:
+            logger.warning("No messages left after filtering")
+            self.context.messages = []
+            return
+
+        logger.info(f"Filtering {len(info_messages)} messages for information content")
+
+        # Filter messages using LLM
+        filtered_memories = self._filter_messages_with_llm(info_messages, user_name, preserved_scores)
+
+        # Store results in context using standardized key
+        self.context.messages = filtered_memories
+        logger.info(f"Filtered to {len(filtered_memories)} high-information messages")
+
+    @staticmethod
+    def _filter_and_process_messages(messages: List[Message], user_name: str, max_size: int) -> List[Message]:
+        """Filter and process messages for information filtering"""
+        info_messages = []
+
+        for msg in messages:
+            # Ensure metadata exists
+
+            # Skip memorized messages
+            if msg.metadata.get('memorized', False):
+                continue
+
+            # Only process messages from the target user
+            # role_name = msg.metadata.get('role_name')
+            # if role_name and role_name != user_name:
+            #     continue
+
+            elif msg.role.value != "user":
+                continue
+
+            # Truncate long messages
+            if len(msg.content) >= max_size:
+                half_size = int(max_size * 0.5 + 0.5)
+                msg.content = msg.content[:half_size] + msg.content[-half_size:]
+
+            info_messages.append(msg)
+
+        logger.info(f"Filtered messages from {len(messages)} to {len(info_messages)}")
+        return info_messages
+
+    def _filter_messages_with_llm(self, info_messages: List[Message], user_name: str, preserved_scores: str) -> List[
+        PersonalMemory]:
+        """Filter messages using LLM to score information content"""
+
+        # Build prompt for information filtering
+        user_query_list = []
+        colon = self._get_colon_word()
+        for i, msg in enumerate(info_messages):
+            user_query_list.append(f"{i + 1} {user_name}{colon} {msg.content}")
+
+        # Create prompt using the prompt format method
+        system_prompt = self.prompt_format(prompt_name="info_filter_system",
+                                           batch_size=len(info_messages),
+                                           user_name=user_name)
+        few_shot = self.prompt_format(prompt_name="info_filter_few_shot", user_name=user_name)
+        user_query = self.prompt_format(prompt_name="info_filter_user_query",
+                                        user_query="\n".join(user_query_list))
+
+        full_prompt = f"{system_prompt}\n\n{few_shot}\n\n{user_query}"
+        logger.info(f"info_filter_prompt={full_prompt}")
+
+        def parse_and_filter(message: Message) -> List[PersonalMemory]:
+            """Parse LLM response and create filtered memories"""
+            response_text = message.content
+            logger.info(f"info_filter_response={response_text}")
+
+            # Parse scores using class method
+            info_scores = InfoFilterOp.parse_info_filter_response(response_text)
+
+            if len(info_scores) != len(info_messages):
+                logger.warning(f"score_size != messages_size, {len(info_scores)} vs {len(info_messages)}")
+
+            filtered_memories = []
+            for idx, score in info_scores:
+                # Convert to 0-based index
+                msg_idx = idx - 1
+                if msg_idx >= len(info_messages):
+                    logger.warning(f"Invalid index {msg_idx} for messages list of length {len(info_messages)}")
+                    continue
+
+                # Check if score should be preserved
+                if score in preserved_scores:
+                    message = info_messages[msg_idx]
+
+                    # Create memory from filtered message with combined metadata
+                    memory = PersonalMemory(
+                        workspace_id=self.context.get("workspace_id", ""),
+                        content=message.content,
+                        target=user_name,
+                        author=getattr(self.llm, "model_name", "system"),
+                        metadata={
+                            "info_score": score,
+                            "filter_type": "info_content",
+                            "original_message_time": getattr(message, 'time_created', None),
+                            "role_name": message.metadata.pop("role_name", user_name),
+                            "memorized": True,
+                            **message.metadata  # Include all original metadata
+                        }
+                    )
+                    filtered_memories.append(memory)
+                    logger.info(f"Info filter: kept message with score {score}: {message.content[:50]}...")
+
+            return filtered_memories
+
+        # Use LLM chat with callback function
+        return self.llm.chat(messages=[Message(content=full_prompt)], callback_fn=parse_and_filter)
+
+    def _get_colon_word(self) -> str:
+        """Get language-specific colon word"""
+        colon_dict = {"zh": "：", "cn": "：", "en": ": "}
+        return colon_dict.get(self.language, ": ")
+
+    @staticmethod
+    def parse_info_filter_response(response_text: str) -> List[tuple]:
+        """Parse info filter response to extract message scores"""
+        # Pattern to match both Chinese and English result formats
+        # Chinese: 结果：<序号> <分数>
+        # English: Result: <Index> <Score>
+        pattern = r"结果：<(\d+)>\s*<([0-3])>|Result:\s*<(\d+)>\s*<([0-3])>"
+        matches = re.findall(pattern, response_text, re.IGNORECASE | re.MULTILINE)
+
+        scores = []
+        for match in matches:
+            # Handle both Chinese and English patterns
+            if match[0]:  # Chinese pattern
+                idx_str, score_str = match[0], match[1]
+            else:  # English pattern
+                idx_str, score_str = match[2], match[3]
+
+            try:
+                idx = int(idx_str)
+                score = score_str
+                scores.append((idx, score))
+            except ValueError:
+                logger.warning(f"Invalid index or score format: {idx_str}, {score_str}")
+                continue
+
+        logger.info(f"Parsed {len(scores)} info filter scores from response")
+        return scores