reme-ai 0.1.0__py3-none-any.whl

reme_ai/retrieve/task/rerank_memory_op.py

@@ -0,0 +1,149 @@
+import json
+import re
+from typing import List
+
+from flowllm import C, BaseLLMOp
+from flowllm.enumeration.role import Role
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.schema.memory import BaseMemory
+
+
+@C.register_op()
+class RerankMemoryOp(BaseLLMOp):
+    """
+    Rerank and filter recalled experiences using LLM and score-based filtering
+    """
+    file_path: str = __file__
+
+    def execute(self):
+        """Execute rerank operation"""
+        memory_list: List[BaseMemory] = self.context.response.metadata["memory_list"]
+        retrieval_query: str = self.context.query
+        enable_llm_rerank = self.op_params.get("enable_llm_rerank", True)
+        enable_score_filter = self.op_params.get("enable_score_filter", False)
+        min_score_threshold = self.op_params.get("min_score_threshold", 0.3)
+        top_k = self.op_params.get("top_k", 5)
+
+        logger.info(f"top_k: {top_k}")
+
+        if not memory_list:
+            logger.info("No recalled memory_list to rerank")
+            return
+
+        logger.info(f"Reranking {len(memory_list)} memories")
+
+        # Step 1: LLM reranking (optional)
+        if enable_llm_rerank:
+            memory_list = self._llm_rerank(retrieval_query, memory_list)
+            logger.info(f"After LLM reranking: {len(memory_list)} memories")
+
+        # Step 2: Score-based filtering (optional)
+        if enable_score_filter:
+            memory_list = self._score_based_filter(memory_list, min_score_threshold)
+            logger.info(f"After score filtering: {len(memory_list)} memories")
+
+        # Step 3: Return top-k results
+        reranked_memories = memory_list[:top_k]
+        logger.info(f"Final reranked results: {len(reranked_memories)} memories")
+
+        # Store results in context
+        self.context.response.metadata["memory_list"] = reranked_memories
+
+    def _llm_rerank(self, query: str, candidates: List[BaseMemory]) -> List[BaseMemory]:
+        """LLM-based reranking of candidate experiences"""
+        if not candidates:
+            return candidates
+
+        # Format candidates for LLM evaluation
+        candidates_text = self._format_candidates_for_rerank(candidates)
+
+        prompt = self.prompt_format(
+            prompt_name="memory_rerank_prompt",
+            query=query,
+            candidates=candidates_text,
+            num_candidates=len(candidates))
+
+        response = self.llm.chat([Message(role=Role.USER, content=prompt)])
+
+        # Parse reranking results
+        reranked_indices = self._parse_rerank_response(response.content)
+
+        # Reorder candidates based on LLM ranking
+        if reranked_indices:
+            reranked_candidates = []
+            for idx in reranked_indices:
+                if 0 <= idx < len(candidates):
+                    reranked_candidates.append(candidates[idx])
+
+            # Add any remaining candidates that weren't explicitly ranked
+            ranked_indices_set = set(reranked_indices)
+            for i, candidate in enumerate(candidates):
+                if i not in ranked_indices_set:
+                    reranked_candidates.append(candidate)
+
+            return reranked_candidates
+
+        return candidates
+
+    @staticmethod
+    def _score_based_filter(memories: List[BaseMemory], min_score: float) -> List[BaseMemory]:
+        """Filter memories based on quality scores"""
+        filtered_memories = []
+
+        for memory in memories:
+            # Get confidence score from metadata
+            confidence = memory.metadata.get("confidence", 0.5)
+            validation_score = memory.score or 0.5
+
+            # Calculate combined score
+            combined_score = (confidence + validation_score) / 2
+
+            if combined_score >= min_score:
+                filtered_memories.append(memory)
+            else:
+                logger.debug(f"Filtered out memory with score {combined_score:.2f}")
+
+        logger.info(f"Score filtering: {len(filtered_memories)}/{len(memories)} memories retained")
+        return filtered_memories
+
+    @staticmethod
+    def _format_candidates_for_rerank(candidates: List[BaseMemory]) -> str:
+        """Format candidates for LLM reranking"""
+        formatted_candidates = []
+
+        for i, candidate in enumerate(candidates):
+            condition = candidate.when_to_use
+            content = candidate.content
+
+            candidate_text = f"Candidate {i}:\n"
+            candidate_text += f"Condition: {condition}\n"
+            candidate_text += f"Experience: {content}\n"
+
+            formatted_candidates.append(candidate_text)
+
+        return "\n---\n".join(formatted_candidates)
+
+    @staticmethod
+    def _parse_rerank_response(response: str) -> List[int]:
+        """Parse LLM reranking response to extract ranked indices"""
+        try:
+            # Try to extract JSON format
+            json_pattern = r'```json\s*([\s\S]*?)\s*```'
+            json_blocks = re.findall(json_pattern, response)
+
+            if json_blocks:
+                parsed = json.loads(json_blocks[0])
+                if isinstance(parsed, dict) and "ranked_indices" in parsed:
+                    return parsed["ranked_indices"]
+                elif isinstance(parsed, list):
+                    return parsed
+
+            # Try to extract numbers from text
+            numbers = re.findall(r'\b\d+\b', response)
+            return [int(num) for num in numbers if int(num) < 100]  # Reasonable upper bound
+
+        except Exception as e:
+            logger.error(f"Error parsing rerank response: {e}")
+            return []

reme_ai/retrieve/task/rewrite_memory_op.py

@@ -0,0 +1,149 @@
+import json
+import re
+from typing import List
+
+from flowllm import C, BaseLLMOp
+from flowllm.enumeration.role import Role
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.schema.memory import BaseMemory
+
+
+@C.register_op()
+class RewriteMemoryOp(BaseLLMOp):
+    """
+    Generate and rewrite context messages from reranked experiences
+    """
+    file_path: str = __file__
+
+    def execute(self):
+        """Execute rewrite operation"""
+        memory_list: List[BaseMemory] = self.context.response.metadata["memory_list"]
+        query: str = self.context.query
+        messages: List[Message] = \
+            [Message(**x) if isinstance(x, dict) else x for x in self.context.get('messages', [])]
+
+        if not memory_list:
+            logger.info("No reranked memories to rewrite")
+            self.context.response.answer = ""
+            return
+
+        logger.info(f"Generating context from {len(memory_list)} memories")
+
+        # Generate initial context message
+        rewritten_memory = self._generate_context_message(query, messages, memory_list)
+
+        # Store results in context
+        self.context.response.answer = rewritten_memory
+        self.context.response.metadata["memory_list"] = [memory.model_dump() for memory in memory_list]
+
+    def _generate_context_message(self, query: str, messages: List[Message], memories: List[BaseMemory]) -> str:
+        """Generate context message from retrieved memories"""
+        if not memories:
+            return ""
+
+        try:
+            logger.info("memories")
+            # Format retrieved memories
+            formatted_memories = self._format_memories_for_context(memories)
+
+            if self.op_params.get("enable_llm_rewrite", True):
+                context_content = self._rewrite_context(query, formatted_memories, messages)
+            else:
+                context_content = formatted_memories
+
+            return context_content
+
+        except Exception as e:
+            logger.error(f"Error generating context message: {e}")
+            return self._format_memories_for_context(memories)
+
+    def _rewrite_context(self, query: str, context_content: str, messages: List[Message]) -> str:
+        """LLM-based context rewriting to make experiences more relevant and actionable"""
+        if not context_content:
+            return context_content
+
+        try:
+            # Extract current context
+            current_context = self._extract_context(messages)
+
+            prompt = self.prompt_format(
+                prompt_name="memory_rewrite_prompt",
+                current_query=query,
+                current_context=current_context,
+                original_context=context_content)
+
+            response = self.llm.chat([Message(role=Role.USER, content=prompt)])
+
+            # Extract rewritten context
+            rewritten_context = self._parse_json_response(response.content, "rewritten_context")
+
+            if rewritten_context and rewritten_context.strip():
+                logger.info("Context successfully rewritten for current task")
+                return rewritten_context.strip()
+
+            return context_content
+
+        except Exception as e:
+            logger.error(f"Error in context rewriting: {e}")
+            return context_content
+
+    @staticmethod
+    def _format_memories_for_context(memories: List[BaseMemory]) -> str:
+        """Format memories for context generation"""
+        formatted_memories = []
+
+        for i, memory in enumerate(memories, 1):
+            condition = memory.when_to_use
+            memory_content = memory.content
+            memory_text = f"Memory {i} :\n When to use: {condition}\n Content: {memory_content}\n"
+
+            formatted_memories.append(memory_text)
+
+        return "\n".join(formatted_memories)
+
+    @staticmethod
+    def _extract_context(messages: List[Message]) -> str:
+        """Extract relevant context from messages"""
+        if not messages:
+            return ""
+
+        context_parts = []
+
+        # Add recent messages if available
+        recent_messages = messages[-3:]  # Last 3 messages
+        message_summaries = []
+        for message in recent_messages:
+            content = message.content[:300] + "..." if len(message.content) > 300 else message.content
+            message_summaries.append(f"- {message.role.value}: {content}")
+
+        if message_summaries:
+            context_parts.append("Recent conversation:\n" + "\n".join(message_summaries))
+
+        return "\n\n".join(context_parts)
+
+    @staticmethod
+    def _parse_json_response(response: str, key: str) -> str:
+        """Parse JSON response to extract specific key"""
+        try:
+            # Try to extract JSON blocks
+            json_pattern = r'```json\s*([\s\S]*?)\s*```'
+            json_blocks = re.findall(json_pattern, response)
+
+            if json_blocks:
+                parsed = json.loads(json_blocks[0])
+                if isinstance(parsed, dict) and key in parsed:
+                    return parsed[key]
+
+            # Fallback: try to parse the entire response as JSON
+            parsed = json.loads(response)
+            if isinstance(parsed, dict) and key in parsed:
+                return parsed[key]
+
+        except json.JSONDecodeError:
+            logger.warning(f"Failed to parse JSON response for key '{key}', using raw response")
+            # If JSON parsing fails, return the response as-is for fallback
+            return response.strip()
+
+        return ""

reme_ai/schema/__init__.py

@@ -0,0 +1 @@
+from flowllm.schema.message import Message, Role, Trajectory  # noqa

reme_ai/schema/memory.py

@@ -0,0 +1,144 @@
+import datetime
+from abc import ABC
+from uuid import uuid4
+
+from flowllm.schema.vector_node import VectorNode
+from pydantic import BaseModel, Field
+
+
+class BaseMemory(BaseModel, ABC):
+    workspace_id: str = Field(default="")
+    memory_id: str = Field(default_factory=lambda: uuid4().hex)
+    memory_type: str = Field(default=...)
+
+    when_to_use: str = Field(default="")
+    content: str | bytes = Field(default="")
+    score: float = Field(default=0)
+
+    time_created: str = Field(default_factory=lambda: datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    time_modified: str = Field(default_factory=lambda: datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    author: str = Field(default="")
+
+    metadata: dict = Field(default_factory=dict)
+
+    def update_modified_time(self):
+        self.time_modified = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def update_metadata(self, new_metadata):
+        self.metadata = new_metadata
+
+    def to_vector_node(self) -> VectorNode:
+        raise NotImplementedError
+
+    @classmethod
+    def from_vector_node(cls, node: VectorNode):
+        raise NotImplementedError
+
+
+class TaskMemory(BaseMemory):
+    memory_type: str = Field(default="task")
+
+    def to_vector_node(self) -> VectorNode:
+        return VectorNode(unique_id=self.memory_id,
+                          workspace_id=self.workspace_id,
+                          content=self.when_to_use,
+                          metadata={
+                              "memory_type": self.memory_type,
+                              "content": self.content,
+                              "score": self.score,
+                              "time_created": self.time_created,
+                              "time_modified": self.time_modified,
+                              "author": self.author,
+                              "metadata": self.metadata,
+                          })
+
+    @classmethod
+    def from_vector_node(cls, node: VectorNode) -> "TaskMemory":
+        metadata = node.metadata.copy()
+        return cls(workspace_id=node.workspace_id,
+                   memory_id=node.unique_id,
+                   memory_type=metadata.pop("memory_type"),
+                   when_to_use=node.content,
+                   content=metadata.pop("content"),
+                   score=metadata.pop("score"),
+                   time_created=metadata.pop("time_created"),
+                   time_modified=metadata.pop("time_modified"),
+                   author=metadata.pop("author"),
+                   metadata=metadata.pop("metadata", {}))
+
+
+class PersonalMemory(BaseMemory):
+    memory_type: str = Field(default="personal")
+    target: str = Field(default="")
+    reflection_subject: str = Field(default="")  # For storing reflection subject attributes
+
+    def to_vector_node(self) -> VectorNode:
+        return VectorNode(unique_id=self.memory_id,
+                          workspace_id=self.workspace_id,
+                          content=self.when_to_use,
+                          metadata={
+                              "memory_type": self.memory_type,
+                              "content": self.content,
+                              "target": self.target,
+                              "reflection_subject": self.reflection_subject,
+                              "score": self.score,
+                              "time_created": self.time_created,
+                              "time_modified": self.time_modified,
+                              "author": self.author,
+                              "metadata": self.metadata,
+                          })
+
+    @classmethod
+    def from_vector_node(cls, node: VectorNode) -> "PersonalMemory":
+        metadata = node.metadata.copy()
+        return cls(workspace_id=node.workspace_id,
+                   memory_id=node.unique_id,
+                   memory_type=metadata.pop("memory_type"),
+                   when_to_use=node.content,
+                   content=metadata.pop("content"),
+                   target=metadata.pop("target", ""),
+                   reflection_subject=metadata.pop("reflection_subject", ""),
+                   score=metadata.pop("score"),
+                   time_created=metadata.pop("time_created"),
+                   time_modified=metadata.pop("time_modified"),
+                   author=metadata.pop("author"),
+                   metadata=metadata.pop("metadata", {}))
+
+
+def vector_node_to_memory(node: VectorNode) -> BaseMemory:
+    memory_type = node.metadata.get("memory_type")
+    if memory_type == "task":
+        return TaskMemory.from_vector_node(node)
+
+    elif memory_type == "personal":
+        return PersonalMemory.from_vector_node(node)
+
+    else:
+        raise RuntimeError(f"memory_type={memory_type} not supported!")
+
+
+def dict_to_memory(memory_dict: dict):
+    memory_type = memory_dict.get("memory_type", "task")
+    if memory_type == "task":
+        return TaskMemory(**memory_dict)
+
+    elif memory_type == "personal":
+        return PersonalMemory(**memory_dict)
+
+    else:
+        raise RuntimeError(f"memory_type={memory_type} not supported!")
+
+
+if __name__ == "__main__":
+    e1 = TaskMemory(
+        workspace_id="w_1024",
+        memory_id="123",
+        when_to_use="test case use",
+        content="test content",
+        score=0.99,
+        metadata={})
+    print(e1.model_dump_json(indent=2))
+    v1 = e1.to_vector_node()
+    print(v1.model_dump_json(indent=2))
+    e2 = vector_node_to_memory(v1)
+    print(e2.model_dump_json(indent=2))

reme_ai/summary/__init__.py

@@ -0,0 +1,2 @@
+from . import personal
+from . import task

reme_ai/summary/personal/__init__.py

@@ -0,0 +1,8 @@
+from .contra_repeat_op import ContraRepeatOp
+from .get_observation_op import GetObservationOp
+from .get_observation_with_time_op import GetObservationWithTimeOp
+from .get_reflection_subject_op import GetReflectionSubjectOp
+from .info_filter_op import InfoFilterOp
+from .load_today_memory_op import LoadTodayMemoryOp
+from .long_contra_repeat_op import LongContraRepeatOp
+from .update_insight_op import UpdateInsightOp

reme_ai/summary/personal/contra_repeat_op.py

@@ -0,0 +1,143 @@
+import json
+import re
+from typing import List, Tuple
+
+from flowllm import C, BaseLLMOp
+from flowllm.enumeration.role import Role
+from flowllm.schema.message import Message
+from loguru import logger
+
+from reme_ai.schema.memory import BaseMemory
+
+
+@C.register_op()
+class ContraRepeatOp(BaseLLMOp):
+    """
+    The `ContraRepeatOp` class specializes in processing memory nodes to identify and handle
+    contradictory and repetitive information. It extends the base functionality of `BaseLLMOp`.
+
+    Responsibilities:
+    - Collects observation memories from context.
+    - Constructs a prompt with these observations for language model analysis.
+    - Parses the model's response to detect contradictions or redundancies.
+    - Filters and returns the processed memories.
+    """
+    file_path: str = __file__
+
+    def execute(self):
+        """
+        Executes the primary routine of the ContraRepeatOp which involves:
+        1. Gets memory list from context
+        2. Constructs a prompt with these memories for language model analysis
+        3. Parses the model's response to detect contradictions or redundancies
+        4. Filters and returns the processed memories
+        """
+        # Get memory list from context - standardized key
+        memory_list: List[BaseMemory] = []
+        memory_list.extend(self.context.get("observation_memories", []))
+        memory_list.extend(self.context.get("observation_memories_with_time", []))
+        memory_list.extend(self.context.get("today_memories", []))
+
+        self.context.response.metadata["memory_list"] = memory_list
+
+        if not memory_list:
+            logger.info("memory_list is empty!")
+            self.context.response.metadata["deleted_memory_ids"] = []
+            return
+
+        # Get operation parameters
+        contra_repeat_max_count: int = self.op_params.get("contra_repeat_max_count", 50)
+        enable_contra_repeat: bool = self.op_params.get("enable_contra_repeat", True)
+
+        if not enable_contra_repeat:
+            logger.warning("contra_repeat is not enabled!")
+            self.context.response.metadata["deleted_memory_ids"] = []
+            return
+
+        # Sort and limit memories by count
+        sorted_memories = sorted(memory_list, key=lambda x: x.time_created, reverse=True)[:contra_repeat_max_count]
+
+        if len(sorted_memories) <= 1:
+            logger.info("sorted_memories.size<=1, stop.")
+            self.context.response.metadata["memory_list"] = sorted_memories
+            self.context.response.metadata["deleted_memory_ids"] = []
+            return
+
+        # Build prompt
+        user_query_list = []
+        for i, memory in enumerate(sorted_memories):
+            user_query_list.append(f"{i + 1} {memory.content}")
+
+        user_name = self.context.get("user_name", "user")
+
+        # Create prompt using the new pattern
+        system_prompt = self.prompt_format(prompt_name="contra_repeat_system",
+                                           num_obs=len(user_query_list),
+                                           user_name=user_name)
+        few_shot = self.prompt_format(prompt_name="contra_repeat_few_shot", user_name=user_name)
+        user_query = self.prompt_format(prompt_name="contra_repeat_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"contra_repeat_prompt={full_prompt}")
+
+        # Call LLM
+        response = self.llm.chat([Message(role=Role.USER, content=full_prompt)])
+
+        # Return if empty
+        if not response or not response.content:
+            logger.warning("Empty response from LLM")
+            self.context.response.metadata["memory_list"] = sorted_memories
+            self.context.response.metadata["deleted_memory_ids"] = []
+            return
+
+        response_text = response.content
+        logger.info(f"contra_repeat_response={response_text}")
+
+        # Parse response and filter memories
+        filtered_memories, deleted_memory_ids = self._parse_and_filter_memories(response_text, sorted_memories)
+
+        # Update context with filtered memories and deleted memory IDs - standardized keys
+        self.context.response.metadata["memory_list"] = filtered_memories
+        self.context.response.metadata["deleted_memory_ids"] = deleted_memory_ids
+        logger.info(f"Filtered {len(memory_list)} memories to {len(filtered_memories)} memories")
+        logger.info(f"Deleted memory IDs: {json.dumps(deleted_memory_ids, indent=2)}")
+
+    @staticmethod
+    def _parse_and_filter_memories(response_text: str, memories: List[BaseMemory]) -> Tuple[
+        List[BaseMemory], List[str]]:
+        """Parse LLM response and filter memories based on contradiction/containment analysis"""
+
+        # Parse the response to extract judgments
+        pattern = r"<(\d+)>\s*<(矛盾|被包含|无|Contradiction|Contained|None)>"
+        matches = re.findall(pattern, response_text, re.IGNORECASE)
+
+        if not matches:
+            logger.warning("No valid judgments found in response")
+            return memories, []
+
+        # Create a set of indices to remove (contradictory or contained memories)
+        indices_to_remove = set()
+        deleted_memory_ids = []
+
+        for idx_str, judgment in matches:
+            try:
+                idx = int(idx_str) - 1  # Convert to 0-based index
+                if idx >= len(memories):
+                    logger.warning(f"Invalid index {idx} for memories list of length {len(memories)}")
+                    continue
+
+                judgment_lower = judgment.lower()
+                if judgment_lower in ['矛盾', 'contradiction', '被包含', 'contained']:
+                    indices_to_remove.add(idx)
+                    deleted_memory_ids.append(memories[idx].memory_id)
+                    logger.info(f"Marking memory {idx + 1} for removal: {judgment} - {memories[idx].content[:100]}...")
+
+            except ValueError:
+                logger.warning(f"Invalid index format: {idx_str}")
+                continue
+
+        # Filter out the memories marked for removal
+        filtered_memories = [memory for i, memory in enumerate(memories) if i not in indices_to_remove]
+
+        return filtered_memories, deleted_memory_ids