reme-ai 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

reme_ai/__init__.py

@@ -3,4 +3,4 @@ from reme_ai import retrieve
 from reme_ai import summary
 from reme_ai import vector_store
 
-__version__ = "0.1.4"
+__version__ = "0.1.5"

reme_ai/app.py

@@ -7,7 +7,7 @@ from reme_ai.config.config_parser import ConfigParser
 
 def main():
     with BaseService.get_service(*sys.argv[1:], parser=ConfigParser) as service:
-        service()
+        service(logo="ReMe")
 
 
 if __name__ == "__main__":

reme_ai/config/default.yaml

@@ -1,4 +1,3 @@
-# default config.yaml
 backend: http
 language: ""
 thread_pool_max_workers: 32
@@ -18,6 +17,9 @@ http:
 flow:
   retrieve_task_memory:
     flow_content: build_query_op >> recall_vector_store_op >> rerank_memory_op >> rewrite_memory_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Retrieves the most relevant top-k memory experiences from historical data based on the current query to enhance task-solving capabilities"
     input_schema:
       query:
@@ -27,6 +29,9 @@ flow:
 
   summary_task_memory:
     flow_content: trajectory_preprocess_op >> (success_extraction_op|failure_extraction_op|comparative_extraction_op) >> memory_validation_op >> update_vector_store_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Summarizes conversation trajectories or messages into structured memory representations for long-term storage"
     input_schema:
       trajectories:
@@ -36,6 +41,9 @@ flow:
 
   retrieve_personal_memory:
     flow_content: set_query_op >> (extract_time_op | (retrieve_memory_op >> semantic_rank_op)) >> fuse_rerank_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Retrieves the most relevant personal memories from historical data based on the query to enhance response quality"
     input_schema:
       query:
@@ -45,6 +53,9 @@ flow:
 
   summary_personal_memory:
     flow_content: info_filter_op >> (get_observation_op | get_observation_with_time_op | load_today_memory_op) >> contra_repeat_op >> update_vector_store_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Consolidates user observations and memories by filtering information and removing redundancies for efficient storage"
     input_schema:
       trajectories:
@@ -54,6 +65,9 @@ flow:
 
   retrieve_task_memory_simple:
     flow_content: build_query_op >> recall_vector_store_op >> merge_memory_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Retrieves the most relevant top-k memory experiences from historical data based on the current query with simplified processing"
     input_schema:
       query:
@@ -63,6 +77,9 @@ flow:
 
   summary_task_memory_simple:
     flow_content: simple_summary_op >> update_vector_store_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Summarizes conversation trajectories or messages into memories using a simplified approach"
     input_schema:
       trajectories:
@@ -72,16 +89,22 @@ flow:
 
   vector_store:
     flow_content: vector_store_action_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Directly operates on the vector store with various management actions"
     input_schema:
       action:
         type: "str"
         description: "vector store operations"
         required: true
-        enum: [ copy, delete, delete_ids, dump, load ]
+        enum: [ copy, delete, delete_ids, dump, load, list]
 
   record_task_memory:
     flow_content: update_memory_freq_op >> update_memory_utility_op >> update_vector_store_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Update the freq & utility attributes of retrieved task memories"
     input_schema:
       workspace_id:
@@ -99,6 +122,9 @@ flow:
 
   delete_task_memory:
     flow_content: delete_memory_op >> update_vector_store_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "Delete task memories when utility/freq < utility_threshold and freq >= freq_threshold"
     input_schema:
       workspace_id:
@@ -116,6 +142,9 @@ flow:
 
   react:
     flow_content: simple_react_op
+    stream: false
+    use_async: true
+    service_type: http+mcp
     description: "React to the current task with an agent"
     input_schema:
       query:
@@ -142,11 +171,18 @@ op:
 llm:
   default:
     backend: openai_compatible
-    #    model_name: qwen3-30b-a3b-thinking-2507
     model_name: qwen3-30b-a3b-instruct-2507
     params:
       temperature: 0.6
 
+  qwen3_30b_instruct:
+    backend: openai_compatible
+    model_name: qwen3-30b-a3b-instruct-2507
+
+  qwen3_30b_thinking:
+    backend: openai_compatible
+    model_name: qwen3-30b-a3b-thinking-2507
+
 embedding_model:
   default:
     backend: openai_compatible
@@ -156,8 +192,7 @@ embedding_model:
 
 vector_store:
   default:
-    backend: elasticsearch
+    backend: memory
     embedding_model: default
 #    params:
 #      hosts: "http://localhost:9200"
-#      hosts: "http://11.160.132.46:8200"

reme_ai/react/simple_react_op.py

@@ -1,21 +1,24 @@
+import asyncio
+
 from flowllm import C
 from flowllm.context.flow_context import FlowContext
-from flowllm.op.agent.react_v2_op import ReactV2Op
+from flowllm.op.llm.react_llm_op import ReactLLMOp
 
 
 @C.register_op()
-class SimpleReactOp(ReactV2Op):
+class SimpleReactOp(ReactLLMOp):
     ...
 
 
-if __name__ == "__main__":
+async def main():
     from reme_ai.config.config_parser import ConfigParser
 
-    C.set_default_service_config(parser=ConfigParser).init_by_service_config()
+    C.set_service_config(parser=ConfigParser, config_name="config=default").init_by_service_config()
     context = FlowContext(query="茅台和五粮现在股价多少？")
 
     op = SimpleReactOp()
-    op(context=context)
-    # from reme_ai.schema import Message
-    # result = op.llm.chat(messages=[Message(**{"role": "user", "content": "你叫什么名字？"})])
-    # print("!!!", result)
+    await op.async_call(context=context)
+    print(context.response.answer)
+
+if __name__ == "__main__":
+    asyncio.run(main())

reme_ai/retrieve/personal/extract_time_op.py

@@ -23,10 +23,9 @@ class ExtractTimeOp(BaseLLMOp):
     """
 
     def get_language_value(self, value_dict: dict):
-
         return value_dict.get(self.language, value_dict.get("en"))
 
-    def execute(self):
+    async def async_execute(self):
         """
         Executes the primary logic of identifying and extracting time data from an LLM's response.
 
@@ -59,7 +58,7 @@ class ExtractTimeOp(BaseLLMOp):
         logger.info(f"Extracting time from query: {query[:100]}...")
 
         # Invoke the LLM to generate a response
-        response = self.llm.chat([Message(role=Role.USER, content=full_prompt)])
+        response = await self.llm.achat([Message(role=Role.USER, content=full_prompt)])
 
         # Handle empty or unsuccessful responses
         if not response or not response.content:

reme_ai/retrieve/personal/fuse_rerank_op.py

@@ -45,7 +45,7 @@ class FuseRerankOp(BaseLLMOp):
         memory.metadata["match_msg_flag"] = str(int(match_msg_flag))
         return match_event_flag, match_msg_flag
 
-    def execute(self):
+    async def async_execute(self):
         """
         Executes the reranking process on memories considering their scores, types, and temporal relevance.
 

reme_ai/retrieve/personal/print_memory_op.py

@@ -13,7 +13,7 @@ class PrintMemoryOp(BaseOp):
     """
     file_path: str = __file__
 
-    def execute(self):
+    async def async_execute(self):
         """
         Executes the primary function, it involves:
         1. Fetches the memories.

reme_ai/retrieve/personal/read_message_op.py

@@ -12,7 +12,7 @@ class ReadMessageOp(BaseOp):
     """
     file_path: str = __file__
 
-    def execute(self):
+    async def async_execute(self):
         """
         Executes the primary function to fetch unmemorized chat messages.
         """

reme_ai/retrieve/personal/retrieve_memory_op.py

@@ -1,13 +1,43 @@
-from flowllm import C
+from typing import List
 
-from reme_ai.vector_store import RecallVectorStoreOp
+from flowllm import C, BaseLLMOp
+from flowllm.schema.vector_node import VectorNode
+from loguru import logger
+
+from reme_ai.schema.memory import BaseMemory, vector_node_to_memory
 
 
 @C.register_op()
-class RetrieveMemoryOp(RecallVectorStoreOp):
+class RetrieveMemoryOp(BaseLLMOp):
     """
     Retrieves memories based on specified criteria such as status, type, and timestamp.
     Processes these memories concurrently, sorts them by similarity, and logs the activity,
     facilitating efficient memory retrieval operations within a given scope.
     """
-    file_path: str = __file__
+
+    async def async_execute(self):
+        recall_key: str = self.op_params.get("recall_key", "query")
+        top_k: int = self.context.get("top_k", 3)
+
+        query: str = self.context[recall_key]
+        assert query, "query should be not empty!"
+
+        workspace_id: str = self.context.workspace_id
+        nodes: List[VectorNode] = await self.vector_store.async_search(query=query,
+                                                                       workspace_id=workspace_id,
+                                                                       top_k=top_k)
+        memory_list: List[BaseMemory] = []
+        memory_content_list: List[str] = []
+        for node in nodes:
+            memory: BaseMemory = vector_node_to_memory(node)
+            if memory.content not in memory_content_list:
+                memory_list.append(memory)
+                memory_content_list.append(memory.content)
+        logger.info(f"retrieve memory.size={len(memory_list)}")
+
+        threshold_score: float | None = self.op_params.get("threshold_score", None)
+        if threshold_score is not None:
+            memory_list = [mem for mem in memory_list if mem.score >= threshold_score or mem.score is None]
+            logger.info(f"after filter by threshold_score size={len(memory_list)}")
+
+        self.context.response.metadata["memory_list"] = memory_list

reme_ai/retrieve/personal/semantic_rank_op.py

@@ -19,7 +19,7 @@ class SemanticRankOp(BaseLLMOp):
     """
     file_path: str = __file__
 
-    def execute(self):
+    async def async_execute(self):
         """
         Executes the primary workflow of the SemanticRankOp which includes:
         - Retrieves query and memory list from context.
@@ -56,7 +56,7 @@ class SemanticRankOp(BaseLLMOp):
             logger.info(f"After deduplication: {len(memory_list)} memories")
 
             # Perform semantic ranking using LLM
-            ranked_memories = self._semantic_rank_memories(query, memory_list)
+            ranked_memories = await self._semantic_rank_memories(query, memory_list)
             if ranked_memories:
                 memory_list = ranked_memories
 
@@ -71,7 +71,7 @@ class SemanticRankOp(BaseLLMOp):
         # Save ranked memories back to context
         self.context.response.metadata["memory_list"] = memory_list
 
-    def _semantic_rank_memories(self, query: str, memories: List[BaseMemory]) -> List[BaseMemory]:
+    async def _semantic_rank_memories(self, query: str, memories: List[BaseMemory]) -> List[BaseMemory]:
         """
         Use LLM to semantically rank memories based on relevance to the query
         """
@@ -93,7 +93,7 @@ Memories:
 Please respond in JSON format:
 {{"rankings": [{{"index": 0, "score": 0.8}}, {{"index": 1, "score": 0.6}}, ...]}}"""
 
-        response = self.llm.chat([Message(role=Role.USER, content=prompt)])
+        response = await self.llm.achat([Message(role=Role.USER, content=prompt)])
 
         if not response or not response.content:
             logger.warning("LLM ranking failed, using original order")

reme_ai/retrieve/personal/set_query_op.py

@@ -14,7 +14,7 @@ class SetQueryOp(BaseOp):
     into the context, utilizing either provided parameters or details from the context.
     """
 
-    def execute(self):
+    async def async_execute(self):
         """
         Executes the operation's primary function, which involves determining the query and its
         timestamp, then storing these values within the context.

reme_ai/retrieve/task/build_query_op.py

@@ -9,7 +9,7 @@ from reme_ai.schema import Message, Role
 class BuildQueryOp(BaseLLMOp):
     file_path: str = __file__
 
-    def execute(self):
+    async def async_execute(self):
         if "query" in self.context:
             query = self.context.query
 
@@ -17,7 +17,7 @@ class BuildQueryOp(BaseLLMOp):
             if self.op_params.get("enable_llm_build", True):
                 execution_process = merge_messages_content(self.context.messages)
                 prompt = self.prompt_format(prompt_name="query_build", execution_process=execution_process)
-                message = self.llm.chat(messages=[Message(role=Role.USER, content=prompt)])
+                message = await self.llm.achat(messages=[Message(role=Role.USER, content=prompt)])
                 query = message.content
 
             else:

reme_ai/retrieve/task/merge_memory_op.py

@@ -9,7 +9,7 @@ from reme_ai.schema.memory import BaseMemory
 @C.register_op()
 class MergeMemoryOp(BaseOp):
 
-    def execute(self):
+    async def async_execute(self):
         memory_list: List[BaseMemory] = self.context.response.metadata["memory_list"]
 
         if not memory_list:

reme_ai/retrieve/task/rerank_memory_op.py

@@ -17,7 +17,7 @@ class RerankMemoryOp(BaseLLMOp):
     """
     file_path: str = __file__
 
-    def execute(self):
+    async def async_execute(self):
         """Execute rerank operation"""
         memory_list: List[BaseMemory] = self.context.response.metadata["memory_list"]
         retrieval_query: str = self.context.query
@@ -36,7 +36,7 @@ class RerankMemoryOp(BaseLLMOp):
 
         # Step 1: LLM reranking (optional)
         if enable_llm_rerank:
-            memory_list = self._llm_rerank(retrieval_query, memory_list)
+            memory_list = await self._llm_rerank(retrieval_query, memory_list)
             logger.info(f"After LLM reranking: {len(memory_list)} memories")
 
         # Step 2: Score-based filtering (optional)
@@ -51,7 +51,7 @@ class RerankMemoryOp(BaseLLMOp):
         # Store results in context
         self.context.response.metadata["memory_list"] = reranked_memories
 
-    def _llm_rerank(self, query: str, candidates: List[BaseMemory]) -> List[BaseMemory]:
+    async def _llm_rerank(self, query: str, candidates: List[BaseMemory]) -> List[BaseMemory]:
         """LLM-based reranking of candidate experiences"""
         if not candidates:
             return candidates
@@ -65,7 +65,7 @@ class RerankMemoryOp(BaseLLMOp):
             candidates=candidates_text,
             num_candidates=len(candidates))
 
-        response = self.llm.chat([Message(role=Role.USER, content=prompt)])
+        response = await self.llm.achat([Message(role=Role.USER, content=prompt)])
 
         # Parse reranking results
         reranked_indices = self._parse_rerank_response(response.content)

reme_ai/retrieve/task/rewrite_memory_op.py

@@ -17,7 +17,7 @@ class RewriteMemoryOp(BaseLLMOp):
     """
     file_path: str = __file__
 
-    def execute(self):
+    async def async_execute(self):
         """Execute rewrite operation"""
         memory_list: List[BaseMemory] = self.context.response.metadata["memory_list"]
         query: str = self.context.query
@@ -32,13 +32,13 @@ class RewriteMemoryOp(BaseLLMOp):
         logger.info(f"Generating context from {len(memory_list)} memories")
 
         # Generate initial context message
-        rewritten_memory = self._generate_context_message(query, messages, memory_list)
+        rewritten_memory = await 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:
+    async def _generate_context_message(self, query: str, messages: List[Message], memories: List[BaseMemory]) -> str:
         """Generate context message from retrieved memories"""
         if not memories:
             return ""
@@ -49,7 +49,7 @@ class RewriteMemoryOp(BaseLLMOp):
             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)
+                context_content = await self._rewrite_context(query, formatted_memories, messages)
             else:
                 context_content = formatted_memories
 
@@ -59,7 +59,7 @@ class RewriteMemoryOp(BaseLLMOp):
             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:
+    async 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
@@ -74,7 +74,7 @@ class RewriteMemoryOp(BaseLLMOp):
                 current_context=current_context,
                 original_context=context_content)
 
-            response = self.llm.chat([Message(role=Role.USER, content=prompt)])
+            response = await self.llm.achat([Message(role=Role.USER, content=prompt)])
 
             # Extract rewritten context
             rewritten_context = self._parse_json_response(response.content, "rewritten_context")

reme_ai/service/base_memory_service.py

@@ -0,0 +1,112 @@
+from abc import abstractmethod, ABC
+from typing import Optional, Dict, Any
+
+from pydantic import Field
+
+
+class BaseMemoryService(ABC):
+
+    def __init__(self):
+        self.session_id_dict: dict = {}
+
+    def add_session_memory_id(self, session_id: str, memory_id):
+        if session_id not in self.session_id_dict:
+            self.session_id_dict[session_id] = []
+
+        self.session_id_dict[session_id].append(memory_id)
+
+    @abstractmethod
+    async def start(self) -> None:
+        """Starts the service, initializing any necessary resources or
+        connections."""
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stops the service, releasing any acquired resources."""
+
+    @abstractmethod
+    async def health(self) -> bool:
+        """
+        Checks the health of the service.
+
+        Returns:
+            True if the service is healthy, False otherwise.
+        """
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.stop()
+        return False
+
+    @abstractmethod
+    async def add_memory(
+            self,
+            user_id: str,
+            messages: list,
+            session_id: Optional[str] = None,
+    ) -> None:
+        """
+        Adds messages to the memory service.
+
+        Args:
+            user_id: The user id.
+            messages: The messages to add.
+            session_id: The session id, which is optional.
+        """
+
+    @abstractmethod
+    async def search_memory(
+            self,
+            user_id: str,
+            messages: list,
+            filters: Optional[Dict[str, Any]] = Field(
+                description="Associated filters for the messages, "
+                            "such as top_k, score etc.",
+                default=None,
+            ),
+    ) -> list:
+        """
+        Searches messages from the memory service.
+
+        Args:
+            user_id: The user id.
+            messages: The user query or the query with history messages,
+                both in the format of list of messages.  If messages is a list,
+                the search will be based on the content of the last message.
+            filters: The filters used to search memory
+        """
+
+    @abstractmethod
+    async def list_memory(
+            self,
+            user_id: str,
+            filters: Optional[Dict[str, Any]] = Field(
+                description="Associated filters for the messages, "
+                            "such as top_k, score etc.",
+                default=None,
+            ),
+    ) -> list:
+        """
+        Lists the memory items for a given user with filters, such as
+        page_num, page_size, etc.
+
+        Args:
+            user_id: The user id.
+            filters: The filters for the memory items.
+        """
+
+    @abstractmethod
+    async def delete_memory(
+            self,
+            user_id: str,
+            session_id: Optional[str] = None,
+    ) -> None:
+        """
+        Deletes the memory items for a given user with certain session id,
+        or all the memory items for a given user.
+        """