MemoryOS 2.0.24__tar.gz → 2.0.25__tar.gz

{memoryos-2.0.24 → memoryos-2.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MemoryOS
-Version: 2.0.24
+Version: 2.0.25
 Summary: Intelligence Begins with Memory
 License: Apache-2.0
 License-File: LICENSE

{memoryos-2.0.24 → memoryos-2.0.25}/pyproject.toml

@@ -4,7 +4,7 @@
 ##############################################################################
 
 name = "MemoryOS"
-version = "2.0.24"
+version = "2.0.25"
 description = "Intelligence Begins with Memory"
 license = {text = "Apache-2.0"}
 readme = "README.md"

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.0.24"
+__version__ = "2.0.25"
 
 from memos.configs.mem_cube import GeneralMemCubeConfig
 from memos.configs.mem_os import MOSConfig

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/api/client.py

@@ -71,6 +71,18 @@ class MemOSClient:
         if bool(user_id) == bool(agent_id):
             raise ValueError("exactly one of user_id or agent_id is required")
 
+    @staticmethod
+    def _normalize_task_status_response(
+        response_data: dict[str, Any], task_id: str
+    ) -> dict[str, Any]:
+        data = response_data.get("data")
+        if not (isinstance(data, list) and len(data) == 1 and isinstance(data[0], dict)):
+            return response_data
+
+        normalized_data = data[0].copy()
+        normalized_data.setdefault("task_id", task_id)
+        return {**response_data, "data": normalized_data}
+
     def _post_json_dict(
         self, endpoint: str, payload: dict[str, Any], operation: str
     ) -> dict[str, Any] | None:
@@ -549,6 +561,7 @@ class MemOSClient:
                 )
                 response.raise_for_status()
                 response_data = response.json()
+                response_data = self._normalize_task_status_response(response_data, task_id)
 
                 return MemOSGetTaskStatusResponse(**response_data)
             except Exception as e:

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/api/config.py

@@ -260,13 +260,56 @@ NacosConfigManager.start_watch_if_enabled()
 class APIConfig:
     """Centralized configuration management for MemOS APIs."""
 
+    _OPENAI_API_BASE = "https://api.openai.com/v1"
+    _QWEN_API_BASE = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+
+    @staticmethod
+    def _is_qwen_model(model_name: str) -> bool:
+        normalized_model = model_name.strip().lower()
+        return normalized_model.startswith("qwen") or "/qwen" in normalized_model
+
     @staticmethod
-    def _preference_extractor_extra_body(model_name: str) -> dict[str, Any] | None:
+    def _qwen_flash_extra_body(model_name: str) -> dict[str, Any] | None:
         normalized_model = model_name.strip().lower()
         if normalized_model.startswith(("qwen3.5", "qwen3.6")):
             return {"enable_thinking": False}
         return None
 
+    @staticmethod
+    def _build_provider_llm_config(
+        model_name: str,
+        *,
+        temperature: float = 0.6,
+        max_tokens: int = 8000,
+        top_p: float = 0.95,
+        top_k: int = 20,
+        remove_think_prefix: bool = True,
+    ) -> dict[str, Any]:
+        """Build task LLM config from model name plus shared provider credentials.
+
+        MEMRADER_MODEL remains a dedicated fine-tuned extractor. Other task-specific
+        model knobs choose only the model; endpoint credentials come from either
+        QWEN_* or OPENAI_* according to the model family.
+        """
+        is_qwen = APIConfig._is_qwen_model(model_name)
+        config = {
+            "model_name_or_path": model_name,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "top_p": top_p,
+            "top_k": top_k,
+            "remove_think_prefix": remove_think_prefix,
+            "api_key": os.getenv("QWEN_API_KEY" if is_qwen else "OPENAI_API_KEY", "EMPTY"),
+            "api_base": os.getenv(
+                "QWEN_API_BASE" if is_qwen else "OPENAI_API_BASE",
+                APIConfig._QWEN_API_BASE if is_qwen else APIConfig._OPENAI_API_BASE,
+            ),
+        }
+        extra_body = APIConfig._qwen_flash_extra_body(model_name) if is_qwen else None
+        if extra_body is not None:
+            config["extra_body"] = extra_body
+        return {"backend": "qwen" if is_qwen else "openai", "config": config}
+
     @staticmethod
     def get_profile_memory_reserved_top_k() -> int:
         """Get profile-memory MMR reserve count.
@@ -293,7 +336,7 @@ class APIConfig:
             "top_k": int(os.getenv("MOS_TOP_K", "50")),
             "remove_think_prefix": True,
             "api_key": os.getenv("OPENAI_API_KEY", "your-api-key-here"),
-            "api_base": os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+            "api_base": os.getenv("OPENAI_API_BASE", APIConfig._OPENAI_API_BASE),
         }
 
     @staticmethod
@@ -357,7 +400,7 @@ class APIConfig:
 
     @staticmethod
     def get_memreader_config() -> dict[str, Any]:
-        """Get MemReader configuration for chat/doc extraction (fine-tuned 0.6B model).
+        """Get the main MemReader configuration for text/chat extraction.
 
         When MEMREADER_GENERAL_MODEL is configured (i.e. a separate stable LLM exists),
         the backup client is automatically enabled so that primary failures (self-deployed
@@ -379,15 +422,11 @@ class APIConfig:
         general_model = os.getenv("MEMREADER_GENERAL_MODEL")
         enable_backup = os.getenv("MEMREADER_ENABLE_BACKUP", "false").lower() == "true"
         if general_model and enable_backup:
+            backup_config = APIConfig._build_provider_llm_config(general_model)["config"]
             config["backup_client"] = True
             config["backup_model_name_or_path"] = general_model
-            config["backup_api_key"] = os.getenv(
-                "MEMREADER_GENERAL_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
-            )
-            config["backup_api_base"] = os.getenv(
-                "MEMREADER_GENERAL_API_BASE",
-                os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
-            )
+            config["backup_api_key"] = backup_config["api_key"]
+            config["backup_api_base"] = backup_config["api_base"]
 
         return {"backend": "openai", "config": config}
 
@@ -395,25 +434,17 @@ class APIConfig:
     def get_qwen_llm_config() -> dict[str, Any] | None:
         if not os.getenv("QWEN_API_KEY"):
             return None
-        return {
-            "backend": "qwen",
-            "config": {
-                "model_name_or_path": os.getenv("QWEN_MODEL", "qwen-flash"),
-                "temperature": float(os.getenv("QWEN_TEMPERATURE", "0.8")),
-                "max_tokens": int(os.getenv("QWEN_MAX_TOKENS", "8000")),
-                "top_p": float(os.getenv("QWEN_TOP_P", "0.9")),
-                "top_k": int(os.getenv("QWEN_TOP_K", "50")),
-                "remove_think_prefix": os.getenv("QWEN_REMOVE_THINK_PREFIX", "true").lower()
-                == "true",
-                "api_key": os.getenv("QWEN_API_KEY", ""),
-                "api_base": os.getenv("QWEN_API_BASE", ""),
-                "model_schema": os.getenv("QWEN_MODEL_SCHEMA", "memos.configs.llm.QwenLLMConfig"),
-            },
-        }
+        return APIConfig._build_provider_llm_config(
+            os.getenv("QWEN_MODEL", "qwen-flash"),
+            temperature=0.8,
+            max_tokens=8000,
+            top_p=0.9,
+            top_k=50,
+        )
 
     @staticmethod
     def get_memreader_general_llm_config() -> dict[str, Any]:
-        """Get general LLM configuration for non-chat/doc tasks.
+        """Get general LLM configuration for non-primary extraction tasks.
 
         Used for: hallucination filter, memory rewrite, memory merge,
         tool trajectory extraction, skill memory extraction.
@@ -428,24 +459,7 @@ class APIConfig:
         # Check if specific general model is configured
         general_model = os.getenv("MEMREADER_GENERAL_MODEL")
         if general_model:
-            return {
-                "backend": os.getenv("MEMREADER_GENERAL_BACKEND", "openai"),
-                "config": {
-                    "model_name_or_path": general_model,
-                    "temperature": 0.6,
-                    "max_tokens": int(os.getenv("MEMREADER_GENERAL_MAX_TOKENS", "8000")),
-                    "top_p": 0.95,
-                    "top_k": 20,
-                    "api_key": os.getenv(
-                        "MEMREADER_GENERAL_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
-                    ),
-                    "api_base": os.getenv(
-                        "MEMREADER_GENERAL_API_BASE",
-                        os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
-                    ),
-                    "remove_think_prefix": True,
-                },
-            }
+            return APIConfig._build_provider_llm_config(general_model)
         # Fallback to memreader config (same behavior as before for users who don't customize)
         return APIConfig.get_memreader_config()
 
@@ -460,27 +474,28 @@ class APIConfig:
         """
         image_model = os.getenv("IMAGE_PARSER_MODEL")
         if image_model:
-            return {
-                "backend": os.getenv("IMAGE_PARSER_BACKEND", "openai"),
-                "config": {
-                    "model_name_or_path": image_model,
-                    "temperature": 0.6,
-                    "max_tokens": int(os.getenv("IMAGE_PARSER_MAX_TOKENS", "4096")),
-                    "top_p": 0.95,
-                    "top_k": 20,
-                    "api_key": os.getenv(
-                        "IMAGE_PARSER_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
-                    ),
-                    "api_base": os.getenv(
-                        "IMAGE_PARSER_API_BASE",
-                        os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
-                    ),
-                    "remove_think_prefix": True,
-                },
-            }
+            return APIConfig._build_provider_llm_config(image_model, max_tokens=4096)
         # Fallback to general_llm config (which itself falls back to OpenAI)
         return APIConfig.get_memreader_general_llm_config()
 
+    @staticmethod
+    def get_document_parser_llm_config() -> dict[str, Any] | None:
+        """Get the dedicated LLM configuration for document extraction.
+
+        The provider endpoint and credentials are selected from QWEN_* or
+        OPENAI_* according to DOCUMENT_PARSER_MODEL.
+
+        Fallback chain: DOCUMENT_PARSER_MODEL -> MEMREADER_GENERAL_MODEL.
+        Returns None when neither model is configured.
+        """
+        document_model = os.getenv("DOCUMENT_PARSER_MODEL") or os.getenv("MEMREADER_GENERAL_MODEL")
+        if not document_model:
+            return None
+        return APIConfig._build_provider_llm_config(
+            document_model,
+            temperature=0.8,
+        )
+
     @staticmethod
     def get_preference_extractor_llm_config() -> dict[str, Any]:
         """Get LLM configuration for preference extraction.
@@ -491,31 +506,23 @@ class APIConfig:
         """
         pref_model = os.getenv("PREFERENCE_EXTRACTOR_MODEL")
         if pref_model:
-            extra_body = APIConfig._preference_extractor_extra_body(pref_model)
-            config = {
-                "model_name_or_path": pref_model,
-                "temperature": 0.6,
-                "max_tokens": int(os.getenv("PREFERENCE_EXTRACTOR_MAX_TOKENS", "8000")),
-                "top_p": 0.95,
-                "top_k": 20,
-                "api_key": os.getenv(
-                    "PREFERENCE_EXTRACTOR_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
-                ),
-                "api_base": os.getenv(
-                    "PREFERENCE_EXTRACTOR_API_BASE",
-                    os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
-                ),
-                "remove_think_prefix": True,
-            }
-            if extra_body is not None:
-                config["extra_body"] = extra_body
-            return {
-                "backend": os.getenv("PREFERENCE_EXTRACTOR_BACKEND", "openai"),
-                "config": config,
-            }
+            return APIConfig._build_provider_llm_config(pref_model)
         # Fallback to general_llm config (which itself falls back to OpenAI)
         return APIConfig.get_memreader_general_llm_config()
 
+    @staticmethod
+    def get_feedback_llm_config() -> dict[str, Any]:
+        """Get LLM configuration for feedback processing.
+
+        Used for: feedback judgement, semantic add/update decisions, and update safety review.
+
+        Fallback chain: FEEDBACK_MODEL -> general_llm -> memreader config.
+        """
+        feedback_model = os.getenv("FEEDBACK_MODEL")
+        if feedback_model:
+            return APIConfig._build_provider_llm_config(feedback_model, temperature=0.8)
+        return APIConfig.get_memreader_general_llm_config()
+
     @staticmethod
     def get_activation_vllm_config() -> dict[str, Any]:
         """Get Ollama configuration."""
@@ -1005,6 +1012,8 @@ class APIConfig:
                     "general_llm": APIConfig.get_memreader_general_llm_config(),
                     # Image parser LLM (requires vision model)
                     "image_parser_llm": APIConfig.get_image_parser_llm_config(),
+                    # Dedicated LLM for document chunk extraction
+                    "document_parser_llm": APIConfig.get_document_parser_llm_config(),
                     # Preference extractor LLM. Reader falls back to general_llm when unset.
                     "preference_extractor_llm": APIConfig.get_preference_extractor_llm_config()
                     if os.getenv("PREFERENCE_EXTRACTOR_MODEL")
@@ -1138,6 +1147,8 @@ class APIConfig:
                     "general_llm": APIConfig.get_memreader_general_llm_config(),
                     # Image parser LLM (requires vision model)
                     "image_parser_llm": APIConfig.get_image_parser_llm_config(),
+                    # Dedicated LLM for document chunk extraction
+                    "document_parser_llm": APIConfig.get_document_parser_llm_config(),
                     # Preference extractor LLM. Reader falls back to general_llm when unset.
                     "preference_extractor_llm": APIConfig.get_preference_extractor_llm_config()
                     if os.getenv("PREFERENCE_EXTRACTOR_MODEL")

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/api/handlers/__init__.py

@@ -20,6 +20,7 @@ from memos.api.handlers import (
 from memos.api.handlers.component_init import init_server
 from memos.api.handlers.config_builders import (
     build_embedder_config,
+    build_feedback_llm_config,
     build_graph_db_config,
     build_internet_retriever_config,
     build_llm_config,
@@ -39,6 +40,7 @@ from memos.api.handlers.formatters_handler import (
 __all__ = [
     "add_handler",
     "build_embedder_config",
+    "build_feedback_llm_config",
     "build_graph_db_config",
     "build_internet_retriever_config",
     "build_llm_config",

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/api/handlers/component_init.py

@@ -13,6 +13,7 @@ from memos.api.config import APIConfig
 from memos.api.handlers.config_builders import (
     build_chat_llm_config,
     build_embedder_config,
+    build_feedback_llm_config,
     build_feedback_reranker_config,
     build_graph_db_config,
     build_internet_retriever_config,
@@ -156,6 +157,7 @@ def init_server() -> dict[str, Any]:
     # Build component configurations
     graph_db_config = build_graph_db_config()
     llm_config = build_llm_config()
+    feedback_llm_config = build_feedback_llm_config()
     chat_llm_config = build_chat_llm_config()
     playground_chat_llm_config = build_chat_llm_config("PLAYGROUND_CHAT_MODEL_LIST")
     embedder_config = build_embedder_config()
@@ -170,6 +172,7 @@ def init_server() -> dict[str, Any]:
     # Create component instances
     graph_db = GraphStoreFactory.from_config(graph_db_config)
     llm = LLMFactory.from_config(llm_config)
+    feedback_llm = LLMFactory.from_config(feedback_llm_config)
     chat_llms = (
         _init_chat_llms(chat_llm_config)
         if os.getenv("ENABLE_CHAT_API", "false") == "true"
@@ -260,7 +263,7 @@ def init_server() -> dict[str, Any]:
 
     # Initialize feedback server
     feedback_server = SimpleMemFeedback(
-        llm=llm,
+        llm=feedback_llm,
         embedder=embedder,
         graph_store=graph_db,
         memory_manager=memory_manager,

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/api/handlers/config_builders.py

@@ -157,6 +157,16 @@ def build_feedback_reranker_config() -> dict[str, Any]:
     return RerankerConfigFactory.model_validate(APIConfig.get_feedback_reranker_config())
 
 
+def build_feedback_llm_config() -> dict[str, Any]:
+    """
+    Build feedback LLM configuration.
+
+    Returns:
+        Validated feedback LLM configuration dictionary
+    """
+    return LLMConfigFactory.model_validate(APIConfig.get_feedback_llm_config())
+
+
 def build_internet_retriever_config() -> dict[str, Any]:
     """
     Build internet retriever configuration.

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/api/handlers/search_handler.py

@@ -16,7 +16,7 @@ from memos.api.handlers.base_handler import BaseHandler, HandlerDependencies
 from memos.api.handlers.formatters_handler import rerank_knowledge_mem
 from memos.api.product_models import APISearchRequest, SearchResponse
 from memos.dream.contextualization import CONTEXT_MEMORY_TYPE
-from memos.log import get_logger
+from memos.log import get_logger, summarize_search_request, summarize_search_results
 from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import (
     cosine_similarity_matrix,
 )
@@ -32,6 +32,8 @@ logger = get_logger(__name__)
 _ENV_CONTEXT_RECALL = "MEMOS_DREAM_CONTEXT_RECALL"
 _ENV_CONTEXT_RECALL_TOP_K = "MEMOS_DREAM_CONTEXT_RECALL_TOP_K"
 _DEFAULT_CONTEXT_RECALL_TOP_K = 2
+_ENV_MMR_CANDIDATE_PRUNING = "MEMOS_MMR_CANDIDATE_PRUNING_ENABLED"
+_MMR_CANDIDATE_MULTIPLIER = 2
 
 
 def _env_enabled(name: str, default: str = "off") -> bool:
@@ -77,7 +79,10 @@ class SearchHandler(BaseHandler):
         Returns:
             SearchResponse with formatted results
         """
-        self.logger.info(f"[SearchHandler] Search Req is: {search_req}")
+        self.logger.info(
+            "[SearchHandler] Search request summary: %s",
+            summarize_search_request(search_req),
+        )
 
         # Use deepcopy to avoid modifying the original request object
         search_req_local = copy.deepcopy(search_req)
@@ -137,7 +142,8 @@ class SearchHandler(BaseHandler):
             results = hooked_results
 
         self.logger.info(
-            f"[SearchHandler] Final search results: count={len(results)} results={results}"
+            "[SearchHandler] Final search result summary: %s",
+            summarize_search_results(results),
         )
 
         return SearchResponse(
@@ -348,6 +354,12 @@ class SearchHandler(BaseHandler):
         if not text_buckets and not pref_buckets:
             return results
 
+        self._prune_mmr_candidates_by_bucket(
+            results,
+            text_top_k=text_top_k,
+            pref_top_k=pref_top_k,
+        )
+
         # Flatten all memories with their type and scores
         # flat structure: (memory_type, bucket_idx, mem, score)
         flat: list[tuple[str, int, dict[str, Any], float]] = []
@@ -552,6 +564,87 @@ class SearchHandler(BaseHandler):
 
         return results
 
+    def _prune_mmr_candidates_by_bucket(
+        self,
+        results: dict[str, Any],
+        *,
+        text_top_k: int,
+        pref_top_k: int,
+    ) -> dict[str, Any]:
+        """Keep at most twice the final quota for each memory type in each bucket."""
+        if not _env_enabled(_ENV_MMR_CANDIDATE_PRUNING, "off"):
+            return results
+
+        total_before = 0
+        total_after = 0
+        bucket_counts: list[tuple[int, int]] = []
+
+        for result_key, target_top_k in (
+            ("text_mem", text_top_k),
+            ("pref_mem", pref_top_k),
+        ):
+            buckets = results.get(result_key)
+            if not isinstance(buckets, list):
+                continue
+
+            candidate_limit = max(0, int(target_top_k)) * _MMR_CANDIDATE_MULTIPLIER
+            for bucket in buckets:
+                memories = bucket.get("memories") if isinstance(bucket, dict) else None
+                if not isinstance(memories, list):
+                    continue
+
+                before_count = len(memories)
+                total_before += before_count
+                memories_by_type: dict[str, list[dict[str, Any]]] = {}
+                for memory in memories:
+                    if not isinstance(memory, dict):
+                        continue
+                    metadata = memory.get("metadata")
+                    memory_type = (
+                        metadata.get("memory_type") if isinstance(metadata, dict) else None
+                    )
+                    memories_by_type.setdefault(str(memory_type or result_key), []).append(memory)
+
+                selected: list[dict[str, Any]] = []
+                if candidate_limit > 0:
+                    for typed_memories in memories_by_type.values():
+                        selected.extend(
+                            sorted(
+                                typed_memories,
+                                key=self._mmr_candidate_score,
+                                reverse=True,
+                            )[:candidate_limit]
+                        )
+                    selected.sort(key=self._mmr_candidate_score, reverse=True)
+
+                bucket["memories"] = selected
+                if "total_nodes" in bucket:
+                    bucket["total_nodes"] = len(selected)
+                total_after += len(selected)
+                bucket_counts.append((before_count, len(selected)))
+
+        self.logger.info(
+            "[SearchHandler] MMR candidate pruning: multiplier=%s before=%s after=%s "
+            "dropped=%s bucket_counts=%s",
+            _MMR_CANDIDATE_MULTIPLIER,
+            total_before,
+            total_after,
+            total_before - total_after,
+            bucket_counts,
+        )
+        return results
+
+    @staticmethod
+    def _mmr_candidate_score(memory: dict[str, Any]) -> float:
+        metadata = memory.get("metadata")
+        if not isinstance(metadata, dict):
+            return 0.0
+        score = metadata.get("score", metadata.get("relativity", 0.0))
+        try:
+            return float(score or 0.0)
+        except (TypeError, ValueError):
+            return 0.0
+
     @staticmethod
     def _is_unrelated(
         index: int,

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/configs/mem_reader.py

@@ -25,7 +25,8 @@ class BaseMemReaderConfig(BaseConfig):
         return value
 
     llm: LLMConfigFactory = Field(
-        ..., description="LLM configuration for chat/doc memory extraction (fine-tuned model)"
+        ...,
+        description="Main LLM configuration for standard text/chat memory extraction",
     )
     general_llm: LLMConfigFactory | None = Field(
         default=None,
@@ -36,6 +37,10 @@ class BaseMemReaderConfig(BaseConfig):
         default=None,
         description="Vision LLM for image parsing. Falls back to general_llm if not set.",
     )
+    document_parser_llm: LLMConfigFactory | None = Field(
+        default=None,
+        description="Dedicated LLM for document content extraction",
+    )
     preference_extractor_llm: LLMConfigFactory | None = Field(
         default=None,
         description="LLM for preference extraction. Falls back to general_llm if not set.",

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/configs/mem_scheduler.py

@@ -212,6 +212,14 @@ class OpenAIConfig(BaseConfig, DictConversionMixin, EnvConfigMixin):
     base_url: str = Field(default="", description="Base URL for API endpoint")
     default_model: str = Field(default="", description="Default model to use")
 
+    @classmethod
+    def from_env(cls) -> "OpenAIConfig":
+        return cls(
+            api_key=os.getenv("OPENAI_API_KEY", ""),
+            base_url=os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+            default_model=os.getenv("MEMSCHEDULER_OPENAI_DEFAULT_MODEL", "gpt-4o-mini"),
+        )
+
 
 class AuthConfig(BaseConfig, DictConversionMixin):
     rabbitmq: RabbitMQConfig | None = None
@@ -339,10 +347,16 @@ class AuthConfig(BaseConfig, DictConversionMixin):
         except (ValueError, Exception) as e:
             logger.warning(f"Failed to initialize RabbitMQ config from environment: {e}")
 
-        # Try to initialize OpenAI config - check if any OpenAI env vars exist
+        # Try to initialize OpenAI config - shared credentials plus scheduler model override.
         try:
-            openai_prefix = OpenAIConfig.get_env_prefix()
-            has_openai_env = any(key.startswith(openai_prefix) for key in os.environ)
+            has_openai_env = any(
+                key in os.environ
+                for key in [
+                    "OPENAI_API_KEY",
+                    "OPENAI_API_BASE",
+                    "MEMSCHEDULER_OPENAI_DEFAULT_MODEL",
+                ]
+            )
             if has_openai_env:
                 openai_config = OpenAIConfig.from_env()
                 logger.info("Successfully initialized OpenAI configuration")
@@ -375,7 +389,7 @@ class AuthConfig(BaseConfig, DictConversionMixin):
         # Set environment variables only if openai config is available
         if self.openai is not None:
             os.environ["OPENAI_API_KEY"] = self.openai.api_key
-            os.environ["OPENAI_BASE_URL"] = self.openai.base_url
+            os.environ["OPENAI_API_BASE"] = self.openai.base_url
             os.environ["MODEL"] = self.openai.default_model
         else:
             logger = logging.getLogger(__name__)

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/configs/parser.py

@@ -17,7 +17,7 @@ class ParserConfigFactory(BaseConfig):
     """Factory class for creating Parser configurations."""
 
     backend: str = Field(..., description="Backend for parser")
-    config: dict[str, Any] = Field(..., description="Configuration for the parser backend")
+    config: BaseParserConfig = Field(..., description="Configuration for the parser backend")
 
     backend_to_class: ClassVar[dict[str, Any]] = {
         "markitdown": MarkItDownParserConfig,
@@ -31,8 +31,23 @@ class ParserConfigFactory(BaseConfig):
             raise ValueError(f"Invalid backend: {backend}")
         return backend
 
-    @model_validator(mode="after")
-    def create_config(self) -> "ParserConfigFactory":
-        config_class = self.backend_to_class[self.backend]
-        self.config = config_class(**self.config)
-        return self
+    @model_validator(mode="before")
+    @classmethod
+    def create_config(cls, data: Any) -> Any:
+        if not isinstance(data, dict):
+            return data
+
+        if "backend" not in data or "config" not in data:
+            return data
+
+        config_class = cls.backend_to_class.get(data["backend"])
+        if config_class is None:
+            return data
+
+        config = data.get("config")
+        if isinstance(config, config_class):
+            return data
+
+        data = data.copy()
+        data["config"] = config_class.model_validate(config)
+        return data

{memoryos-2.0.24 → memoryos-2.0.25}/src/memos/embedders/ark.py

@@ -1,6 +1,6 @@
 from memos.configs.embedder import ArkEmbedderConfig
 from memos.dependency import require_python_package
-from memos.embedders.base import BaseEmbedder
+from memos.embedders.base import BaseEmbedder, log_embedding_call
 from memos.log import get_logger
 
 
@@ -35,6 +35,7 @@ class ArkEmbedder(BaseEmbedder):
         # Initialize ark client
         self.client = Ark(api_key=self.config.api_key, base_url=self.config.api_base)
 
+    @log_embedding_call
     def embed(self, texts: list[str]) -> list[list[float]]:
         """
         Generate embeddings for the given texts.