♻️ Improvement: Warn the user trying to proceed when embedding model is not set

Author: Phinease

backend/services/config_sync_service.py

@@ -26,13 +26,6 @@
 logger = logging.getLogger("config_sync_service")
 
 
-def _parse_optional_int(value) -> Optional[int]:
-    try:
-        return int(value)
-    except (ValueError, TypeError):
-        return None
-
-
 def handle_model_config(tenant_id: str, user_id: str, config_key: str, model_id: Optional[int], tenant_config_dict: dict) -> None:
     """
     Handle model configuration updates, deletions, and settings operations
@@ -56,7 +49,8 @@ def handle_model_config(tenant_id: str, user_id: str, config_key: str, model_id:
             user_id, tenant_id, config_key, model_id)
         return
 
-    current_model_id = _parse_optional_int(tenant_config_dict.get(config_key))
+    current_model_id = tenant_config_dict.get(config_key)
+    current_model_id = int(current_model_id) if str(current_model_id).isdigit() else None
 
     if current_model_id == model_id:
         tenant_config_manager.update_single_config(tenant_id, config_key)

backend/services/memory_config_service.py

@@ -2,20 +2,20 @@
 from typing import Dict, List, Union
 
 from consts.const import (
-    MEMORY_SWITCH_KEY,
-    MEMORY_AGENT_SHARE_KEY,
-    DISABLE_AGENT_ID_KEY,
-    DISABLE_USERAGENT_ID_KEY,
-    DEFAULT_MEMORY_SWITCH_KEY,
-    DEFAULT_MEMORY_AGENT_SHARE_KEY,
+	MEMORY_SWITCH_KEY,
+	MEMORY_AGENT_SHARE_KEY,
+	DISABLE_AGENT_ID_KEY,
+	DISABLE_USERAGENT_ID_KEY,
+	DEFAULT_MEMORY_SWITCH_KEY,
+	DEFAULT_MEMORY_AGENT_SHARE_KEY,
 )
 from consts.model import MemoryAgentShareMode
 from database.memory_config_db import (
-    get_all_configs_by_user_id,
-    get_memory_config_info,
-    insert_config,
-    delete_config_by_config_id,
-    update_config_by_id,
+	get_all_configs_by_user_id,
+	get_memory_config_info,
+	insert_config,
+	delete_config_by_config_id,
+	update_config_by_id,
 )
 from nexent.core.agents.agent_model import MemoryContext, MemoryUserConfig
 from utils.memory_utils import build_memory_config
@@ -31,15 +31,15 @@
 # ---------------------------------------------------------------------------
 
 def _aggregate_records(records: List[Dict[str, Union[str, int]]]) -> Dict[str, Union[str, List[str]]]:
-    """Aggregate DB rows -> {config_key: value_or_list}"""
-    aggregated: Dict[str, Union[str, List[str]]] = {}
-    for r in records:
-        key = r["config_key"]
-        if r.get("value_type") == _MULTI_TYPE:
-            aggregated.setdefault(key, []).append(r["config_value"])
-        else:
-            aggregated[key] = r["config_value"]
-    return aggregated
+	"""Aggregate DB rows -> {config_key: value_or_list}"""
+	aggregated: Dict[str, Union[str, List[str]]] = {}
+	for r in records:
+		key = r["config_key"]
+		if r.get("value_type") == _MULTI_TYPE:
+			aggregated.setdefault(key, []).append(r["config_value"])
+		else:
+			aggregated[key] = r["config_value"]
+	return aggregated
 
 
 # ---------------------------------------------------------------------------
@@ -64,154 +64,154 @@ def get_user_configs(user_id: str) -> Dict[str, Union[str, List[str]]]:
 
 
 def _update_single_config(user_id: str, config_key: str, config_value: str) -> bool:
-    """Create or update a single-type configuration entry."""
-    record_list = get_memory_config_info(user_id, config_key)
-
-    if not record_list:
-        # Insert new record
-        result = insert_config({
-            "user_id": user_id,
-            "config_key": config_key,
-            "config_value": config_value,
-            "value_type": _SINGLE_TYPE,
-            "created_by": user_id,
-            "updated_by": user_id,
-        })
-        if not result:
-            logger.error(
-                f"insert_config failed, user_id={user_id}, key={config_key}, value={config_value}"
-            )
-            return False
-    else:
-        # Update first record (there should be max one for single type)
-        config_id = record_list[0]["config_id"]
-        result = update_config_by_id(config_id, {
-            "config_value": config_value,
-            "updated_by": user_id,
-        })
-        if not result:
-            logger.error(
-                f"update_config_by_id failed, user_id={user_id}, key={config_key}, value={config_value}"
-            )
-            return False
-    return True
+	"""Create or update a single-type configuration entry."""
+	record_list = get_memory_config_info(user_id, config_key)
+
+	if not record_list:
+		# Insert new record
+		result = insert_config({
+			"user_id": user_id,
+			"config_key": config_key,
+			"config_value": config_value,
+			"value_type": _SINGLE_TYPE,
+			"created_by": user_id,
+			"updated_by": user_id,
+		})
+		if not result:
+			logger.error(
+				f"insert_config failed, user_id={user_id}, key={config_key}, value={config_value}"
+			)
+			return False
+	else:
+		# Update first record (there should be max one for single type)
+		config_id = record_list[0]["config_id"]
+		result = update_config_by_id(config_id, {
+			"config_value": config_value,
+			"updated_by": user_id,
+		})
+		if not result:
+			logger.error(
+				f"update_config_by_id failed, user_id={user_id}, key={config_key}, value={config_value}"
+			)
+			return False
+	return True
 
 
 def _add_multi_value(user_id: str, config_key: str, value: str) -> bool:
-    """Add a value to a multi-type list if it does not exist."""
-    record_list = get_memory_config_info(user_id, config_key)
-    if any(r["config_value"] == value for r in record_list):
-        # Already exists, nothing to do
-        return True
-
-    ok = insert_config({
-        "user_id": user_id,
-        "config_key": config_key,
-        "config_value": value,
-        "value_type": _MULTI_TYPE,
-        "created_by": user_id,
-        "updated_by": user_id,
-    })
-    if not ok:
-        logger.error(
-            f"insert_config failed, user_id={user_id}, key={config_key}, value={value}"
-        )
-    return ok
+	"""Add a value to a multi-type list if it does not exist."""
+	record_list = get_memory_config_info(user_id, config_key)
+	if any(r["config_value"] == value for r in record_list):
+		# Already exists, nothing to do
+		return True
+
+	ok = insert_config({
+		"user_id": user_id,
+		"config_key": config_key,
+		"config_value": value,
+		"value_type": _MULTI_TYPE,
+		"created_by": user_id,
+		"updated_by": user_id,
+	})
+	if not ok:
+		logger.error(
+			f"insert_config failed, user_id={user_id}, key={config_key}, value={value}"
+		)
+	return ok
 
 
 def _remove_multi_value(user_id: str, config_key: str, value: str) -> bool:
-    """Soft-delete a specific value from a multi-type configuration list."""
-    record_list = get_memory_config_info(user_id, config_key)
-    for r in record_list:
-        if r["config_value"] == value:
-            ok = delete_config_by_config_id(r["config_id"], updated_by=user_id)
-            if not ok:
-                logger.error(
-                    f"delete_config_by_config_id failed, user_id={user_id}, key={config_key}, value={value}"
-                )
-            return ok
-    # Value not found → treat as success
-    return True
+	"""Soft-delete a specific value from a multi-type configuration list."""
+	record_list = get_memory_config_info(user_id, config_key)
+	for r in record_list:
+		if r["config_value"] == value:
+			ok = delete_config_by_config_id(r["config_id"], updated_by=user_id)
+			if not ok:
+				logger.error(
+					f"delete_config_by_config_id failed, user_id={user_id}, key={config_key}, value={value}"
+				)
+			return ok
+	# Value not found → treat as success
+	return True
 
 
 # ---------------------------------------------------------------------------
 # Public service helpers used by API layer
 # ---------------------------------------------------------------------------
 
 def get_memory_switch(user_id: str) -> bool:
-    configs = get_user_configs(user_id)
-    return configs.get(MEMORY_SWITCH_KEY, "N") == "Y"
+	configs = get_user_configs(user_id)
+	return configs.get(MEMORY_SWITCH_KEY, "N") == "Y"
 
 
 def set_memory_switch(user_id: str, enabled: bool) -> bool:
-    return _update_single_config(user_id, MEMORY_SWITCH_KEY, "Y" if enabled else "N")
+	return _update_single_config(user_id, MEMORY_SWITCH_KEY, "Y" if enabled else "N")
 
 
 # Agent share (single string among always/ask/never)
 def get_agent_share(user_id: str) -> MemoryAgentShareMode:
-    configs = get_user_configs(user_id)
-    mode_str = configs.get(MEMORY_AGENT_SHARE_KEY, MemoryAgentShareMode.NEVER.value)
-    try:
-        return MemoryAgentShareMode(mode_str)
-    except ValueError:
-        # Unexpected value, default to NEVER
-        return MemoryAgentShareMode.NEVER
+	configs = get_user_configs(user_id)
+	mode_str = configs.get(MEMORY_AGENT_SHARE_KEY, MemoryAgentShareMode.NEVER.value)
+	try:
+		return MemoryAgentShareMode(mode_str)
+	except ValueError:
+		# Unexpected value, default to NEVER
+		return MemoryAgentShareMode.NEVER
 
 
 def set_agent_share(user_id: str, mode: MemoryAgentShareMode) -> bool:
-    return _update_single_config(user_id, MEMORY_AGENT_SHARE_KEY, mode.value)
+	return _update_single_config(user_id, MEMORY_AGENT_SHARE_KEY, mode.value)
 
 
 # Disable agent id list (multi)
 def get_disabled_agent_ids(user_id: str) -> List[str]:
-    configs = get_user_configs(user_id)
-    return configs.get(DISABLE_AGENT_ID_KEY, [])  # type: ignore[return-value]
+	configs = get_user_configs(user_id)
+	return configs.get(DISABLE_AGENT_ID_KEY, [])  # type: ignore[return-value]
 
 
 def add_disabled_agent_id(user_id: str, agent_id: str) -> bool:
-    return _add_multi_value(user_id, DISABLE_AGENT_ID_KEY, agent_id)
+	return _add_multi_value(user_id, DISABLE_AGENT_ID_KEY, agent_id)
 
 
 def remove_disabled_agent_id(user_id: str, agent_id: str) -> bool:
-    return _remove_multi_value(user_id, DISABLE_AGENT_ID_KEY, agent_id)
+	return _remove_multi_value(user_id, DISABLE_AGENT_ID_KEY, agent_id)
 
 
 # Disable user-agent id list (multi)
 
 def get_disabled_useragent_ids(user_id: str) -> List[str]:
-    configs = get_user_configs(user_id)
-    return configs.get(DISABLE_USERAGENT_ID_KEY, [])  # type: ignore[return-value]
+	configs = get_user_configs(user_id)
+	return configs.get(DISABLE_USERAGENT_ID_KEY, [])  # type: ignore[return-value]
 
 
 def add_disabled_useragent_id(user_id: str, ua_id: str) -> bool:
-    return _add_multi_value(user_id, DISABLE_USERAGENT_ID_KEY, ua_id)
+	return _add_multi_value(user_id, DISABLE_USERAGENT_ID_KEY, ua_id)
 
 
 def remove_disabled_useragent_id(user_id: str, ua_id: str) -> bool:
-    return _remove_multi_value(user_id, DISABLE_USERAGENT_ID_KEY, ua_id)
+	return _remove_multi_value(user_id, DISABLE_USERAGENT_ID_KEY, ua_id)
 
 
 def build_memory_context(user_id: str, tenant_id: str, agent_id: str | int) -> MemoryContext:
-    memory_user_config = MemoryUserConfig(
-        memory_switch=get_memory_switch(user_id),
-        agent_share_option=get_agent_share(user_id).value,
-        disable_agent_ids=get_disabled_agent_ids(user_id),
-        disable_user_agent_ids=get_disabled_useragent_ids(user_id),
-    )
-    # If user turn off the memory function, return minimum context directly
-    if not memory_user_config.memory_switch:
-        return MemoryContext(
-            user_config=memory_user_config,
-            memory_config=dict(),
-            tenant_id=tenant_id,
-            user_id=user_id,
-            agent_id=str(agent_id),
-        )
-
-    return MemoryContext(
-        user_config=memory_user_config,
-        memory_config=build_memory_config(tenant_id),
-        tenant_id=tenant_id,
-        user_id=user_id,
-        agent_id=str(agent_id),
-    )
+	memory_user_config = MemoryUserConfig(
+		memory_switch=get_memory_switch(user_id),
+		agent_share_option=get_agent_share(user_id).value,
+		disable_agent_ids=get_disabled_agent_ids(user_id),
+		disable_user_agent_ids=get_disabled_useragent_ids(user_id),
+	)
+	# If user turn off the memory function, return minimum context directly
+	if not memory_user_config.memory_switch:
+		return MemoryContext(
+			user_config=memory_user_config,
+			memory_config=dict(),
+			tenant_id=tenant_id,
+			user_id=user_id,
+			agent_id=str(agent_id),
+		)
+
+	return MemoryContext(
+		user_config=memory_user_config,
+		memory_config=build_memory_config(tenant_id),
+		tenant_id=tenant_id,
+		user_id=user_id,
+		agent_id=str(agent_id),
+	)

backend/utils/memory_utils.py

@@ -29,6 +29,11 @@ def build_memory_config(tenant_id: str) -> Dict[str, Any]:
         raise ValueError("ES_HOST must include scheme, host and port, e.g. http://host:9200")
     es_host = f"{parsed.scheme}://{parsed.hostname}"
     es_port = parsed.port
+    index_name = (
+        f"mem0_{embed_raw['model_repo'].lower()}_{embed_raw['model_name'].lower()}_{embed_raw['max_tokens']}"
+        if embed_raw["model_repo"]
+        else f"mem0_{embed_raw['model_name'].lower()}_{embed_raw['max_tokens']}"
+    )
 
     # 3. Assemble final configuration
     memory_config: Dict[str, Any] = {
@@ -52,7 +57,7 @@ def build_memory_config(tenant_id: str) -> Dict[str, Any]:
         "vector_store": {
             "provider": "elasticsearch",
             "config": {
-                "collection_name": "mem0",
+                "collection_name": index_name,
                 "host": es_host,
                 "port": es_port,
                 "embedding_model_dims": embed_raw["max_tokens"],