feat(cli): add ReMeCli class with interactive chat functionality

Author: jinliyl

pyproject.toml

@@ -109,7 +109,7 @@ Repository = "https://github.com/agentscope-ai/ReMe"
 [project.scripts]
 reme = "reme_ai.main:main"
 reme2 = "reme.reme:main"
-remefs = "reme.reme_fs:main"
+remecli = "reme.reme_cli:main"
 
 [tool.pytest.ini_options]
 asyncio_default_fixture_loop_scope = "function"

reme/__init__.py

@@ -6,6 +6,7 @@
 from . import tool
 from . import workflow
 from .reme import ReMe
+from .reme_cli import ReMeCli
 from .reme_fs import ReMeFs
 
 __all__ = [
@@ -15,10 +16,11 @@
     "tool",
     "workflow",
     "ReMe",
+    "ReMeCli",
     "ReMeFs",
 ]
 
-__version__ = "0.3.0.0a4"
+__version__ = "0.3.0.0a5"
 
 
 """

reme/agent/chat/fs_cli.py

@@ -20,10 +20,6 @@ def __init__(
         context_window_tokens: int = 128000,
         reserve_tokens: int = 36000,
         keep_recent_tokens: int = 20000,
-        hybrid_enabled: bool = True,
-        hybrid_vector_weight: float = 0.7,
-        hybrid_text_weight: float = 0.3,
-        hybrid_candidate_multiplier: float = 3.0,
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -32,10 +28,6 @@ def __init__(
         self.context_window_tokens: int = context_window_tokens
         self.reserve_tokens: int = reserve_tokens
         self.keep_recent_tokens: int = keep_recent_tokens
-        self.hybrid_enabled: bool = hybrid_enabled
-        self.hybrid_vector_weight: float = hybrid_vector_weight
-        self.hybrid_text_weight: float = hybrid_text_weight
-        self.hybrid_candidate_multiplier: float = hybrid_candidate_multiplier
 
         self.messages: list[Message] = []
         self.previous_summary: str = ""
@@ -168,7 +160,7 @@ async def execute(self):
         messages = await self.build_messages()
         for i, message in enumerate(messages):
             role = message.name or message.role
-            logger.info(f"[{self.__class__.__name__}] role={role} {message.simple_dump(as_dict=False)}")
+            logger.info(f"[{self.__class__.__name__}] msg[{i}] role={role} {message.simple_dump(as_dict=False)}")
 
         t_tools, messages, success = await self.react(messages, self.tools)
 

reme/agent/fs/fs_summarizer.py

@@ -29,13 +29,29 @@ async def build_messages(self) -> list[Message]:
                     role=Role.USER,
                     content=self.prompt_format(
                         "user_message_default",
-                        conversation=format_messages(messages, add_index=False),
                         working_dir=self.working_dir,
                         date=date_str,
                         memory_dir=self.memory_dir,
                     ),
                 ),
             )
+
+        elif self.version == "v1":
+            conversation = format_messages(messages, add_index=False)
+            messages = [
+                Message(
+                    role=Role.USER,
+                    content=f"<conversation>\n{conversation}\n</conversation>\n"
+                    + self.prompt_format(
+                        "user_message_default",
+                        conversation=format_messages(messages, add_index=False),
+                        working_dir=self.working_dir,
+                        date=date_str,
+                        memory_dir=self.memory_dir,
+                    ),
+                ),
+            ]
+
         else:
             messages.extend(
                 [

reme/config/fs.yaml

@@ -18,13 +18,15 @@ embedding_models:
 memory_stores:
   default:
     backend: sqlite
-    store_name: test_hybrid
+    store_name: reme
     embedding_model: default
     fts_enabled: true
+    vector_enabled: false
 
 file_watchers:
   default:
     backend: full
+    memory_store: default
     watch_paths: [".reme", ".reme/memory"]
     suffix_filters: [".md"]
     recursive: false

reme/core/application.py

@@ -24,6 +24,7 @@ def __init__(
         llm_base_url: str | None = None,
         embedding_api_key: str | None = None,
         embedding_base_url: str | None = None,
+        working_dir: str | None = None,
         config_path: str | None = None,
         enable_logo: bool = True,
         log_to_console: bool = True,
@@ -44,6 +45,7 @@ def __init__(
             embedding_base_url=embedding_base_url,
             service_config=None,
             parser=parser,
+            working_dir=working_dir,
             config_path=config_path,
             enable_logo=enable_logo,
             log_to_console=log_to_console,

reme/core/context/service_context.py

@@ -2,6 +2,7 @@
 
 import os
 from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from loguru import logger
@@ -34,6 +35,7 @@ def __init__(
         embedding_base_url: str | None = None,
         service_config: ServiceConfig | None = None,
         parser: type[PydanticConfigParser] | None = None,
+        working_dir: str | None = None,
         config_path: str | None = None,
         enable_logo: bool = True,
         log_to_console: bool = True,
@@ -74,13 +76,23 @@ def __init__(
                 self._update_section_config(kwargs, "memory_stores", **default_memory_store_config)
             if default_file_watcher_config:
                 self._update_section_config(kwargs, "file_watchers", **default_file_watcher_config)
-            kwargs["enable_logo"] = enable_logo
-            kwargs["log_to_console"] = log_to_console
+
+            kwargs.update(
+                {
+                    "enable_logo": enable_logo,
+                    "log_to_console": log_to_console,
+                    "working_dir": working_dir,
+                },
+            )
             logger.info(f"update with args: {input_args} kwargs: {kwargs}")
             service_config = parser.parse_args(*input_args, **kwargs)
 
         self.service_config: ServiceConfig = service_config
         init_logger(log_to_console=self.service_config.log_to_console)
+        logger.info(f"ReMe Config: {service_config.model_dump_json()}")
+
+        if self.service_config.working_dir:
+            Path(self.service_config.working_dir).mkdir(parents=True, exist_ok=True)
 
         if self.service_config.enable_logo:
             print_logo(service_config=self.service_config)
@@ -147,41 +159,58 @@ def _build_flows(self):
     async def start(self):
         """Start the service context by initializing all configured components."""
         for name, config in self.service_config.llms.items():
-            self.llms[name] = R.llms[config.backend](model_name=config.model_name, **config.model_extra)
+            if config.backend not in R.llms:
+                logger.warning(f"LLM backend {config.backend} is not supported.")
+            else:
+                self.llms[name] = R.llms[config.backend](model_name=config.model_name, **config.model_extra)
 
         for name, config in self.service_config.embedding_models.items():
-            self.embedding_models[name] = R.embedding_models[config.backend](
-                model_name=config.model_name,
-                **config.model_extra,
-            )
+            if config.backend not in R.embedding_models:
+                logger.warning(f"Embedding model backend {config.backend} is not supported.")
+            else:
+                self.embedding_models[name] = R.embedding_models[config.backend](
+                    model_name=config.model_name,
+                    **config.model_extra,
+                )
 
         for name, config in self.service_config.token_counters.items():
-            self.token_counters[name] = R.token_counters[config.backend](
-                model_name=config.model_name,
-                **config.model_extra,
-            )
+            if config.backend not in R.token_counters:
+                logger.warning(f"Token counter backend {config.backend} is not supported.")
+            else:
+                self.token_counters[name] = R.token_counters[config.backend](
+                    model_name=config.model_name,
+                    **config.model_extra,
+                )
 
         for name, config in self.service_config.vector_stores.items():
-            # Extract config dict and replace special fields with actual instances
-            config_dict = config.model_dump(exclude={"backend", "embedding_model"})
-            config_dict["embedding_model"] = self.embedding_models[config.embedding_model]
-            config_dict["thread_pool"] = self.thread_pool
-            self.vector_stores[name] = R.vector_stores[config.backend](**config_dict)
-            await self.vector_stores[name].create_collection(config.collection_name)
+            if config.backend not in R.vector_stores:
+                logger.warning(f"Vector store backend {config.backend} is not supported.")
+            else:
+                # Extract config dict and replace special fields with actual instances
+                config_dict = config.model_dump(exclude={"backend", "embedding_model"})
+                config_dict["embedding_model"] = self.embedding_models[config.embedding_model]
+                config_dict["thread_pool"] = self.thread_pool
+                self.vector_stores[name] = R.vector_stores[config.backend](**config_dict)
+                await self.vector_stores[name].create_collection(config.collection_name)
 
         for name, config in self.service_config.memory_stores.items():
-            # Extract config dict and replace embedding_model string with actual instance
-            config_dict = config.model_dump(exclude={"backend", "embedding_model"})
-            config_dict["embedding_model"] = self.embedding_models[config.embedding_model]
-            self.memory_stores[name] = R.memory_stores[config.backend](**config_dict)
-            await self.memory_stores[name].start()
+            if config.backend not in R.memory_stores:
+                logger.warning(f"Memory store backend {config.backend} is not supported.")
+            else:
+                # Extract config dict and replace embedding_model string with actual instance
+                config_dict = config.model_dump(exclude={"backend", "embedding_model"})
+                config_dict["embedding_model"] = self.embedding_models[config.embedding_model]
+                self.memory_stores[name] = R.memory_stores[config.backend](**config_dict)
+                await self.memory_stores[name].start()
 
         for name, config in self.service_config.file_watchers.items():
-            # Extract config dict and replace memory_store string with actual instance
-            config_dict = config.model_dump(exclude={"backend", "memory_store"})
-            config_dict["memory_store"] = self.memory_stores[config.memory_store]
-            self.file_watchers[name] = R.file_watchers[config.backend](**config_dict)
-            await self.file_watchers[name].start()
+            if config.backend not in R.file_watchers:
+                logger.warning(f"File watcher backend {config.backend} is not supported.")
+            else:
+                config_dict = config.model_dump(exclude={"backend", "memory_store"})
+                config_dict["memory_store"] = self.memory_stores[config.memory_store]
+                self.file_watchers[name] = R.file_watchers[config.backend](**config_dict)
+                await self.file_watchers[name].start()
 
         if self.service_config.mcp_servers:
             await self.prepare_mcp_servers()

reme/core/file_watcher/full_file_watcher.py

@@ -5,7 +5,6 @@
 """
 
 import asyncio
-import os
 from pathlib import Path
 
 from loguru import logger

reme/core/memory_store/base_memory_store.py

@@ -15,6 +15,7 @@ def __init__(
         self,
         store_name: str,
         embedding_model: BaseEmbeddingModel,
+        vector_enabled: bool = False,
         fts_enabled: bool = True,
         **kwargs,
     ):
@@ -23,14 +24,17 @@ def __init__(
         # Only allow alphanumeric characters and underscores
         if not re.match(r"^[a-zA-Z0-9_]+$", store_name):
             raise ValueError(f"Invalid '{store_name}'. Only alphanumeric characters and underscores are allowed.")
+
+        # Ensure at least one search method is enabled
+        if not vector_enabled and not fts_enabled:
+            raise ValueError("At least one of vector_enabled or fts_enabled must be True.")
+
         self.store_name: str = store_name
         self.embedding_model: BaseEmbeddingModel = embedding_model
+        self.vector_enabled: bool = vector_enabled
         self.fts_enabled: bool = fts_enabled
         self.kwargs: dict = kwargs
 
-        self.vector_available = False
-        self.fts_available = False
-
     @property
     def embedding_dim(self) -> int:
         """Get the embedding model's dimensionality."""