Feat/memory (#11812)

### What problem does this PR solve?

Manage and display memory datasets.

### Type of change


- [x] New Feature (non-breaking change which adds functionality)

api/apps/memories_app.py

@@ -0,0 +1,185 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+
+from quart import request
+from api.apps import login_required, current_user
+from api.db import TenantPermission
+from api.db.services.memory_service import MemoryService
+from api.db.services.user_service import UserTenantService
+from api.utils.api_utils import validate_request, get_request_json, get_error_argument_result, get_json_result, \
+    not_allowed_parameters
+from api.utils.memory_utils import format_ret_data_from_memory, get_memory_type_human
+from api.constants import MEMORY_NAME_LIMIT, MEMORY_SIZE_LIMIT
+from common.constants import MemoryType, RetCode, ForgettingPolicy
+
+
+@manager.route("", methods=["POST"])  # noqa: F821
+@login_required
+@validate_request("name", "memory_type", "embd_id", "llm_id")
+async def create_memory():
+    req = await get_request_json()
+    # check name length
+    name = req["name"]
+    memory_name = name.strip()
+    if len(memory_name) == 0:
+        return get_error_argument_result("Memory name cannot be empty or whitespace.")
+    if len(memory_name) > MEMORY_NAME_LIMIT:
+        return get_error_argument_result(f"Memory name '{memory_name}' exceeds limit of {MEMORY_NAME_LIMIT}.")
+    # check memory_type valid
+    memory_type = set(req["memory_type"])
+    invalid_type = memory_type - {e.name.lower() for e in MemoryType}
+    if invalid_type:
+        return get_error_argument_result(f"Memory type '{invalid_type}' is not supported.")
+    memory_type = list(memory_type)
+
+    try:
+        res, memory = MemoryService.create_memory(
+            tenant_id=current_user.id,
+            name=memory_name,
+            memory_type=memory_type,
+            embd_id=req["embd_id"],
+            llm_id=req["llm_id"]
+        )
+
+        if res:
+            return get_json_result(message=True, data=format_ret_data_from_memory(memory))
+
+        else:
+            return get_json_result(message=memory, code=RetCode.SERVER_ERROR)
+
+    except Exception as e:
+        return get_json_result(message=str(e), code=RetCode.SERVER_ERROR)
+
+
+@manager.route("/<memory_id>", methods=["PUT"])  # noqa: F821
+@login_required
+@not_allowed_parameters("id", "tenant_id", "memory_type", "storage_type", "embd_id")
+async def update_memory(memory_id):
+    req = await get_request_json()
+    update_dict = {}
+    # check name length
+    if "name" in req:
+        name = req["name"]
+        memory_name = name.strip()
+        if len(memory_name) == 0:
+            return get_error_argument_result("Memory name cannot be empty or whitespace.")
+        if len(memory_name) > MEMORY_NAME_LIMIT:
+            return get_error_argument_result(f"Memory name '{memory_name}' exceeds limit of {MEMORY_NAME_LIMIT}.")
+        update_dict["name"] = memory_name
+    # check permissions valid
+    if req.get("permissions"):
+        if req["permissions"] not in [e.value for e in TenantPermission]:
+            return get_error_argument_result(f"Unknown permission '{req['permissions']}'.")
+        update_dict["permissions"] = req["permissions"]
+    if req.get("llm_id"):
+        update_dict["llm_id"] = req["llm_id"]
+    # check memory_size valid
+    if req.get("memory_size"):
+        if not 0 < int(req["memory_size"]) <= MEMORY_SIZE_LIMIT:
+            return get_error_argument_result(f"Memory size should be in range (0, {MEMORY_SIZE_LIMIT}] Bytes.")
+        update_dict["memory_size"] = req["memory_size"]
+    # check forgetting_policy valid
+    if req.get("forgetting_policy"):
+        if req["forgetting_policy"] not in [e.value for e in ForgettingPolicy]:
+            return get_error_argument_result(f"Forgetting policy '{req['forgetting_policy']}' is not supported.")
+        update_dict["forgetting_policy"] = req["forgetting_policy"]
+    # check temperature valid
+    if "temperature" in req:
+        temperature = float(req["temperature"])
+        if not 0 <= temperature <= 1:
+            return get_error_argument_result("Temperature should be in range [0, 1].")
+        update_dict["temperature"] = temperature
+    # allow update to empty fields
+    for field in ["avatar", "description", "system_prompt", "user_prompt"]:
+        if field in req:
+            update_dict[field] = req[field]
+    current_memory = MemoryService.get_by_memory_id(memory_id)
+    if not current_memory:
+        return get_json_result(code=RetCode.NOT_FOUND, message=f"Memory '{memory_id}' not found.")
+
+    memory_dict = current_memory.to_dict()
+    memory_dict.update({"memory_type": get_memory_type_human(current_memory.memory_type)})
+    to_update = {}
+    for k, v in update_dict.items():
+        if isinstance(v, list) and set(memory_dict[k]) != set(v):
+            to_update[k] = v
+        elif memory_dict[k] != v:
+            to_update[k] = v
+
+    if not to_update:
+        return get_json_result(message=True, data=memory_dict)
+
+    try:
+        MemoryService.update_memory(memory_id, to_update)
+        updated_memory = MemoryService.get_by_memory_id(memory_id)
+        return get_json_result(message=True, data=format_ret_data_from_memory(updated_memory))
+
+    except Exception as e:
+        logging.error(e)
+        return get_json_result(message=str(e), code=RetCode.SERVER_ERROR)
+
+
+@manager.route("/<memory_id>", methods=["DELETE"]) # noqa: F821
+@login_required
+async def delete_memory(memory_id):
+    memory = MemoryService.get_by_memory_id(memory_id)
+    if not memory:
+        return get_json_result(message=True, code=RetCode.NOT_FOUND)
+    try:
+        MemoryService.delete_memory(memory_id)
+        return get_json_result(message=True)
+    except Exception as e:
+        logging.error(e)
+        return get_json_result(message=str(e), code=RetCode.SERVER_ERROR)
+
+
+@manager.route("", methods=["GET"]) # noqa: F821
+@login_required
+async def list_memory():
+    args = request.args
+    try:
+        tenant_ids = args.getlist("tenant_id")
+        memory_types = args.getlist("memory_type")
+        storage_type = args.get("storage_type")
+        keywords = args.get("keywords", "")
+        page = int(args.get("page", 1))
+        page_size = int(args.get("page_size", 50))
+        # make filter dict
+        filter_dict = {"memory_type": memory_types, "storage_type": storage_type}
+        if not tenant_ids:
+            # restrict to current user's tenants
+            user_tenants = UserTenantService.get_user_tenant_relation_by_user_id(current_user.id)
+            filter_dict["tenant_id"] = [tenant["tenant_id"] for tenant in user_tenants]
+        else:
+            filter_dict["tenant_id"] = tenant_ids
+
+        memory_list, count = MemoryService.get_by_filter(filter_dict, keywords, page, page_size)
+        [memory.update({"memory_type": get_memory_type_human(memory["memory_type"])}) for memory in memory_list]
+        return get_json_result(message=True, data={"memory_list": memory_list, "total_count": count})
+
+    except Exception as e:
+        logging.error(e)
+        return get_json_result(message=str(e), code=RetCode.SERVER_ERROR)
+
+
+@manager.route("/<memory_id>/config", methods=["GET"])  # noqa: F821
+@login_required
+async def get_memory_config(memory_id):
+    memory = MemoryService.get_with_owner_name_by_id(memory_id)
+    if not memory:
+        return get_json_result(code=RetCode.NOT_FOUND, message=f"Memory '{memory_id}' not found.")
+    return get_json_result(message=True, data=format_ret_data_from_memory(memory))

api/constants.py

@@ -24,3 +24,5 @@ REQUEST_MAX_WAIT_SEC = 300
 
 DATASET_NAME_LIMIT = 128
 FILE_NAME_LEN_LIMIT = 255
+MEMORY_NAME_LIMIT = 128
+MEMORY_SIZE_LIMIT = 10*1024*1024 # Byte

api/db/db_models.py

@@ -1177,6 +1177,27 @@ class EvaluationResult(DataBaseModel):
         db_table = "evaluation_results"
 
 
+class Memory(DataBaseModel):
+    id = CharField(max_length=32, primary_key=True)
+    name = CharField(max_length=128, null=False, index=False, help_text="Memory name")
+    avatar = TextField(null=True, help_text="avatar base64 string")
+    tenant_id = CharField(max_length=32, null=False, index=True)
+    memory_type = IntegerField(null=False, default=1, index=True, help_text="Bit flags (LSB->MSB): 1=raw, 2=semantic, 4=episodic, 8=procedural. E.g., 5 enables raw + episodic.")
+    storage_type = CharField(max_length=32, default='table', null=False, index=True, help_text="table|graph")
+    embd_id = CharField(max_length=128, null=False, index=False, help_text="embedding model ID")
+    llm_id = CharField(max_length=128, null=False, index=False, help_text="chat model ID")
+    permissions = CharField(max_length=16, null=False, index=True, help_text="me|team", default="me")
+    description = TextField(null=True, help_text="description")
+    memory_size = IntegerField(default=5242880, null=False, index=False)
+    forgetting_policy = CharField(max_length=32, null=False, default="fifo", index=False, help_text="lru|fifo")
+    temperature = FloatField(default=0.5, index=False)
+    system_prompt = TextField(null=True, help_text="system prompt", index=False)
+    user_prompt = TextField(null=True, help_text="user prompt", index=False)
+
+    class Meta:
+        db_table = "memory"
+
+
 def migrate_db():
     logging.disable(logging.ERROR)
     migrator = DatabaseMigrator[settings.DATABASE_TYPE.upper()].value(DB)
@@ -1357,7 +1378,7 @@ def migrate_db():
         migrate(migrator.add_column("llm_factories", "rank", IntegerField(default=0, index=False)))
     except Exception:
         pass
-    
+
     # RAG Evaluation tables
     try:
         migrate(migrator.add_column("evaluation_datasets", "id", CharField(max_length=32, primary_key=True)))
@@ -1395,5 +1416,5 @@ def migrate_db():
         migrate(migrator.add_column("evaluation_datasets", "status", IntegerField(null=False, default=1)))
     except Exception:
         pass
-    
+
     logging.disable(logging.NOTSET)

api/db/services/memory_service.py

@@ -0,0 +1,150 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from typing import List
+
+from api.apps import current_user
+from api.db.db_models import DB, Memory, User
+from api.db.services import duplicate_name
+from api.db.services.common_service import CommonService
+from api.utils.memory_utils import calculate_memory_type
+from api.constants import MEMORY_NAME_LIMIT
+from common.misc_utils import get_uuid
+from common.time_utils import get_format_time, current_timestamp
+
+
+class MemoryService(CommonService):
+    # Service class for manage memory operations
+    model = Memory
+
+    @classmethod
+    @DB.connection_context()
+    def get_by_memory_id(cls, memory_id: str):
+        return cls.model.select().where(cls.model.id == memory_id).first()
+
+    @classmethod
+    @DB.connection_context()
+    def get_with_owner_name_by_id(cls, memory_id: str):
+        fields = [
+            cls.model.id,
+            cls.model.name,
+            cls.model.avatar,
+            cls.model.tenant_id,
+            User.nickname.alias("owner_name"),
+            cls.model.memory_type,
+            cls.model.storage_type,
+            cls.model.embd_id,
+            cls.model.llm_id,
+            cls.model.permissions,
+            cls.model.description,
+            cls.model.memory_size,
+            cls.model.forgetting_policy,
+            cls.model.temperature,
+            cls.model.system_prompt,
+            cls.model.user_prompt
+        ]
+        memory = cls.model.select(*fields).join(User, on=(cls.model.tenant_id == User.id)).where(
+            cls.model.id == memory_id
+        ).first()
+        return memory
+
+    @classmethod
+    @DB.connection_context()
+    def get_by_filter(cls, filter_dict: dict, keywords: str, page: int = 1, page_size: int = 50):
+        fields = [
+            cls.model.id,
+            cls.model.name,
+            cls.model.avatar,
+            cls.model.tenant_id,
+            User.nickname.alias("owner_name"),
+            cls.model.memory_type,
+            cls.model.storage_type,
+            cls.model.permissions,
+            cls.model.description
+        ]
+        memories = cls.model.select(*fields).join(User, on=(cls.model.tenant_id == User.id))
+        if filter_dict.get("tenant_id"):
+            memories = memories.where(cls.model.tenant_id.in_(filter_dict["tenant_id"]))
+        if filter_dict.get("memory_type"):
+            memory_type_int = calculate_memory_type(filter_dict["memory_type"])
+            memories = memories.where(cls.model.memory_type.bin_and(memory_type_int) > 0)
+        if filter_dict.get("storage_type"):
+            memories = memories.where(cls.model.storage_type == filter_dict["storage_type"])
+        if keywords:
+            memories = memories.where(cls.model.name.contains(keywords))
+        count = memories.count()
+        memories = memories.order_by(cls.model.update_time.desc())
+        memories = memories.paginate(page, page_size)
+
+        return list(memories.dicts()), count
+
+    @classmethod
+    @DB.connection_context()
+    def create_memory(cls, tenant_id: str, name: str, memory_type: List[str], embd_id: str, llm_id: str):
+        # Deduplicate name within tenant
+        memory_name = duplicate_name(
+            cls.query,
+            name=name,
+            tenant_id=tenant_id
+        )
+        if len(memory_name) > MEMORY_NAME_LIMIT:
+            return False, f"Memory name {memory_name} exceeds limit of {MEMORY_NAME_LIMIT}."
+
+        # build create dict
+        memory_info = {
+            "id": get_uuid(),
+            "name": memory_name,
+            "memory_type": calculate_memory_type(memory_type),
+            "tenant_id": tenant_id,
+            "embd_id": embd_id,
+            "llm_id": llm_id,
+            "create_time": current_timestamp(),
+            "create_date": get_format_time(),
+            "update_time": current_timestamp(),
+            "update_date": get_format_time(),
+        }
+        obj = cls.model(**memory_info).save(force_insert=True)
+
+        if not obj:
+            return False, "Could not create new memory."
+
+        db_row = cls.model.select().where(cls.model.id == memory_info["id"]).first()
+
+        return obj, db_row
+
+    @classmethod
+    @DB.connection_context()
+    def update_memory(cls, memory_id: str, update_dict: dict):
+        if not update_dict:
+            return 0
+        if "temperature" in update_dict and isinstance(update_dict["temperature"], str):
+            update_dict["temperature"] = float(update_dict["temperature"])
+        if "name" in update_dict:
+            update_dict["name"] = duplicate_name(
+                cls.query,
+                name=update_dict["name"],
+                tenant_id=current_user.id
+            )
+        update_dict.update({
+            "update_time": current_timestamp(),
+            "update_date": get_format_time()
+        })
+
+        return cls.model.update(update_dict).where(cls.model.id == memory_id).execute()
+
+    @classmethod
+    @DB.connection_context()
+    def delete_memory(cls, memory_id: str):
+        return cls.model.delete().where(cls.model.id == memory_id).execute()

api/utils/memory_utils.py

@@ -0,0 +1,54 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from typing import List
+from common.constants import MemoryType
+
+def format_ret_data_from_memory(memory):
+    return {
+        "id": memory.id,
+        "name": memory.name,
+        "avatar": memory.avatar,
+        "tenant_id": memory.tenant_id,
+        "owner_name": memory.owner_name if hasattr(memory, "owner_name") else None,
+        "memory_type": get_memory_type_human(memory.memory_type),
+        "storage_type": memory.storage_type,
+        "embd_id": memory.embd_id,
+        "llm_id": memory.llm_id,
+        "permissions": memory.permissions,
+        "description": memory.description,
+        "memory_size": memory.memory_size,
+        "forgetting_policy": memory.forgetting_policy,
+        "temperature": memory.temperature,
+        "system_prompt": memory.system_prompt,
+        "user_prompt": memory.user_prompt,
+        "create_time": memory.create_time,
+        "create_date": memory.create_date,
+        "update_time": memory.update_time,
+        "update_date": memory.update_date
+    }
+
+
+def get_memory_type_human(memory_type: int) -> List[str]:
+    return [mem_type.name.lower() for mem_type in MemoryType if memory_type & mem_type.value]
+
+
+def calculate_memory_type(memory_type_name_list: List[str]) -> int:
+    memory_type = 0
+    type_value_map = {mem_type.name.lower(): mem_type.value for mem_type in MemoryType}
+    for mem_type in memory_type_name_list:
+        if mem_type in type_value_map:
+            memory_type |= type_value_map[mem_type]
+    return memory_type