Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
Feat/searchable template (#2193)
chenjw82225006fb92
diff --git a/examples/ov.conf.example b/examples/ov.conf.exampleindex e6254f63a..453af2a1c 100644--- a/examples/ov.conf.example+++ b/examples/ov.conf.example@@ -159,7 +159,7 @@"version": "v2","extraction_enabled": true,"session_skill_extraction_enabled": false,- "enable_role_id_memory_isolate": false,+ "role_id_memory_isolation_enabled": false,},"log": {"level": "INFO",diff --git a/openviking/prompts/templates/memory/entities.yaml b/openviking/prompts/templates/memory/entities.yamlindex 2990d70b5..2e4c5c0ea 100644--- a/openviking/prompts/templates/memory/entities.yaml+++ b/openviking/prompts/templates/memory/entities.yaml@@ -1,11 +1,17 @@memory_type: entitiesdescription: |Wikipedia article - manages page using Zettelkasten method.- Each page represents an article with relative path links to events.Entity should be rich and distributed - avoid putting all info in one entity.directory: "viking://user/{{ user_space }}/memories/entities"filename_template: "{{ category }}/{{ name }}.md"enabled: true+embedding_template: |-+ {{ category }}++ {{ name }}++ {{ content }}+overview_template: |-# Entities Overview@@ -21,14 +27,12 @@ fields:- Category name written in {{ language }}.{% if language == 'en' %}Use lowercase with underscores, max 3 words.{% else %}Keep it concise and natural in {{ language }}.{% endif %}merge_op: immutable- searchable: true- name: nametype: stringdescription: |- Entity name in Chinese or English. If English, use lowercase with underscores, max 3 words.merge_op: immutable- searchable: true- name: contenttype: stringdiff --git a/openviking/prompts/templates/memory/events.yaml b/openviking/prompts/templates/memory/events.yamlindex ebf726f51..afefddd70 100644--- a/openviking/prompts/templates/memory/events.yaml+++ b/openviking/prompts/templates/memory/events.yaml@@ -20,6 +20,12 @@ content_template: |{{ summary }}{{extract_context.get_first_message_time_with_weekday_from_ranges(ranges|default(''))|default('N/A')}} ChatLog:{{ extract_context.get_event_content(ranges, summary, 0) }}+embedding_template: |-+ {{ event_name }}++ {{ goal }}++ {{ content }}overview_template: |-# Events Overview@@ -42,20 +48,17 @@ fields:6. Patterns like "person_chat", "chat_about_xxx", "daily_talk" are forbidden;7. Output only the event name, no extra explanation.merge_op: immutable- searchable: true- name: goaltype: stringdescription: |Summarize the purpose of the content in 5 words or less- searchable: true- name: summarytype: stringdescription: |Based on the content of the above fields, compile a description to outline the complete Fact content.Use specific year-month-day dates instead of vague terms such as yesterday, last week, and tomorrow.- searchable: true- name: rangestype: stringdiff --git a/openviking/prompts/templates/memory/preferences.yaml b/openviking/prompts/templates/memory/preferences.yamlindex 010275243..6c89a5386 100644--- a/openviking/prompts/templates/memory/preferences.yaml+++ b/openviking/prompts/templates/memory/preferences.yaml@@ -11,6 +11,12 @@ description: |directory: "viking://user/{{ user_space }}/memories/preferences"filename_template: "{{ user }}/{{ topic }}.md"enabled: true+embedding_template: |-+ {{ user }}++ {{ topic }}++ {{ content }}overview_template: |-# Preferences Overview@@ -26,7 +32,6 @@ fields:description: |Username for the preference ownermerge_op: immutable- searchable: true- name: topictype: string@@ -38,7 +43,6 @@ fields:Different preference topics should be stored as separate memories, do not mix unrelated preferences.If a topic becomes too broad, split it into smaller semantic subtopics.merge_op: immutable- searchable: true- name: contenttype: stringdiff --git a/openviking/session/memory/__init__.py b/openviking/session/memory/__init__.pyindex 82e9fb49f..1a0a506f2 100644--- a/openviking/session/memory/__init__.py+++ b/openviking/session/memory/__init__.py@@ -20,10 +20,7 @@ from openviking.session.memory.extract_loop import (from openviking.session.memory.memory_type_registry import MemoryTypeRegistryfrom openviking.session.memory.memory_updater import MemoryUpdater, MemoryUpdateResultfrom openviking.session.memory.merge_op import FieldType, MergeOp-from openviking.session.memory.schema_model_generator import (- SchemaModelGenerator,- SchemaPromptGenerator,-)+from openviking.session.memory.schema_model_generator import SchemaModelGeneratorfrom openviking.session.memory.tools import (MemoryLsTool,MemoryReadTool,@@ -55,7 +52,6 @@ __all__ = ["MemoryTypeRegistry",# Schema models"SchemaModelGenerator",- "SchemaPromptGenerator",# Updater"MemoryUpdater","MemoryUpdateResult",diff --git a/openviking/session/memory/agent_experience_context_provider.py b/openviking/session/memory/agent_experience_context_provider.pyindex 8481e6f6c..8fbe354a0 100644--- a/openviking/session/memory/agent_experience_context_provider.py+++ b/openviking/session/memory/agent_experience_context_provider.py@@ -10,17 +10,17 @@ No tool calls — all context is prefetched. Top-3 candidates also include theirsource_trajectories as grounding material."""-import jinja2from typing import Any, Dict, List, Optionalfrom openviking.core.namespace import to_agent_space, to_user_space-from openviking.server.identity import RequestContext, ToolContext+from openviking.server.identity import RequestContextfrom openviking.session.memory.dataclass import MemoryFilefrom openviking.session.memory.session_extract_context_provider import (SessionExtractContextProvider,)from openviking.session.memory.tools import add_tool_call_pair_to_messagesfrom openviking.session.memory.utils.memory_file_utils import MemoryFileUtils+from openviking.session.memory.utils.template_utils import TemplateUtilsfrom openviking.storage.viking_fs import VikingFSfrom openviking.telemetry import tracerfrom openviking_cli.utils import get_logger@@ -106,9 +106,12 @@ All memory content must be written in {output_language}.user_space = "default"agent_space = "default"- env = jinja2.Environment(autoescape=False)- return env.from_string(schema.directory).render(- user_space=user_space, agent_space=agent_space+ return TemplateUtils.render(+ schema.directory,+ {+ "user_space": user_space,+ "agent_space": agent_space,+ },)async def _load_source_trajectories(diff --git a/openviking/session/memory/dataclass.py b/openviking/session/memory/dataclass.pyindex 75a785cf6..2e7f1d2c9 100644--- a/openviking/session/memory/dataclass.py+++ b/openviking/session/memory/dataclass.py@@ -148,9 +148,6 @@ class MemoryField(BaseModel):description: str = Field("", description="Field description")merge_op: MergeOp = Field(MergeOp.PATCH, description="Merge strategy")init_value: Optional[str] = Field(None, description="Initial value for this field")- searchable: bool = Field(- False, description="Whether this field's value contributes to embedding text"- )class MemoryTypeSchema(BaseModel):@@ -163,6 +160,7 @@ class MemoryTypeSchema(BaseModel):content_template: Optional[str] = Field(None, description="Content template (for template mode)")+ embedding_template: Optional[str] = Field(None, description="Embedding text template")directory: str = Field("", description="Directory path")enabled: bool = Field(True, description="Whether this memory type is enabled")operation_mode: str = Field(diff --git a/openviking/session/memory/extract_loop.py b/openviking/session/memory/extract_loop.pyindex ecd039183..4d4187eef 100644--- a/openviking/session/memory/extract_loop.py+++ b/openviking/session/memory/extract_loop.py@@ -20,10 +20,7 @@ from openviking.session.memory.dataclass import ()from openviking.session.memory.memory_isolation_handler import MemoryIsolationHandlerfrom openviking.session.memory.merge_op import MergeOp-from openviking.session.memory.schema_model_generator import (- SchemaModelGenerator,- SchemaPromptGenerator,-)+from openviking.session.memory.schema_model_generator import SchemaModelGeneratorfrom openviking.session.memory.tools import (MEMORY_TOOLS_REGISTRY,add_tool_call_pair_to_messages,@@ -86,7 +83,6 @@ class ExtractLoop:# Schema 生成器(在 run() 中初始化)self.schema_model_generator = None- self.schema_prompt_generator = None# 预计算:避免每次迭代重复计算self._tool_schemas: Optional[List[Dict[str, Any]]] = None@@ -125,10 +121,6 @@ class ExtractLoop:schemas,template_context={"language": output_language},)- self.schema_prompt_generator = SchemaPromptGenerator(- schemas,- template_context={"language": output_language},- )self.schema_model_generator.generate_all_models()# 预计算工具 schemas@@ -166,8 +158,6 @@ class ExtractLoop:import jsonschema_str = json.dumps(json_schema, ensure_ascii=False)- type_descriptions = self.schema_prompt_generator.generate_type_descriptions()-messages = []page_id_rules = """## Page ID Rules@@ -188,7 +178,6 @@ class ExtractLoop:"role": "system","content": f"""{self.context_provider.instruction()}-{type_descriptions}{page_id_rules}{link_rules}## Read Format Rulesdiff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.pyindex d0836ecde..5913e1232 100644--- a/openviking/session/memory/memory_isolation_handler.py+++ b/openviking/session/memory/memory_isolation_handler.py@@ -36,13 +36,13 @@ class MemoryIsolationHandler:self.ctx = ctxself._extract_context = extract_contextconfig = get_openviking_config()- self.enable_role_id_memory_isolate = (- config.memory.enable_role_id_memory_isolate if config.memory else False+ self.role_id_memory_isolation_enabled = (+ config.memory.role_id_memory_isolation_enabled if config.memory else False)def prepare_messages(self) -> None:- """开关关闭时,清空 messages 中的 role_id,使下游统一使用登录用户。"""- if self.enable_role_id_memory_isolate:+ """开关关闭时,规范化 messages 中的 role_id,缺失时回退到登录身份。"""+ if self.role_id_memory_isolation_enabled:returnmessages = self._extract_context.messages if self._extract_context else []for msg in messages:diff --git a/openviking/session/memory/memory_type_registry.py b/openviking/session/memory/memory_type_registry.pyindex 865a7d98e..0f0b5542f 100644--- a/openviking/session/memory/memory_type_registry.py+++ b/openviking/session/memory/memory_type_registry.py@@ -14,6 +14,7 @@ from openviking.prompts.manager import PromptManagerfrom openviking.session.memory.dataclass import MemoryField, MemoryTypeSchemafrom openviking.session.memory.merge_op import MergeOpfrom openviking.session.memory.merge_op.base import FieldType+from openviking.session.memory.utils.template_utils import TemplateUtilsfrom openviking_cli.utils import get_loggerlogger = get_logger(__name__)@@ -141,14 +142,16 @@ class MemoryTypeRegistry:Returns:List of directory URIs from enabled schemas"""- import jinja2-uris = []for schema in self.list_all(include_disabled=False):if schema.directory:- env = jinja2.Environment(autoescape=False)- template = env.from_string(schema.directory)- dir_path = template.render(user_space=user_space, agent_space=agent_space)+ dir_path = TemplateUtils.render(+ schema.directory,+ {+ "user_space": user_space,+ "agent_space": agent_space,+ },+ )uris.append(dir_path)return uris@@ -215,7 +218,6 @@ class MemoryTypeRegistry:description=field_data.get("description", ""),merge_op=MergeOp(field_data.get("merge_op", "patch")),init_value=field_data.get("init_value"),- searchable=field_data.get("searchable", False),)fields.append(field)@@ -225,6 +227,7 @@ class MemoryTypeRegistry:fields=fields,filename_template=data.get("filename_template", ""),content_template=data.get("content_template"),+ embedding_template=data.get("embedding_template"),directory=data.get("directory", ""),enabled=data.get("enabled", data.get("enable", True)),operation_mode=data.get("operation_mode", "upsert"),@@ -242,8 +245,6 @@ class MemoryTypeRegistry:Args:ctx: Request context (must have user with user_space_name and agent_space_name)"""- import jinja2-from openviking.storage.viking_fs import get_viking_fslogger = get_logger(__name__)@@ -255,7 +256,6 @@ class MemoryTypeRegistry:f"[MemoryTypeRegistry] Starting memory files initialization for user={user_space}, agent={agent_space}")- env = jinja2.Environment(autoescape=False)viking_fs = get_viking_fs()for schema in self.list_all(include_disabled=False):@@ -276,13 +276,19 @@ class MemoryTypeRegistry:# Render directory and filename from schematry:- directory = env.from_string(schema.directory).render(- user_space=user_space,- agent_space=agent_space,+ directory = TemplateUtils.render(+ schema.directory,+ {+ "user_space": user_space,+ "agent_space": agent_space,+ },)- filename = env.from_string(schema.filename_template).render(- user_space=user_space,- agent_space=agent_space,+ filename = TemplateUtils.render(+ schema.filename_template,+ {+ "user_space": user_space,+ "agent_space": agent_space,+ },)except Exception:continuediff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.pyindex bdc13570d..2d4021b8b 100644--- a/openviking/session/memory/memory_updater.py+++ b/openviking/session/memory/memory_updater.py@@ -26,6 +26,7 @@ from openviking.session.memory.memory_type_registry import MemoryTypeRegistryfrom openviking.session.memory.merge_op import MergeOpFactoryfrom openviking.session.memory.page_id_map import PageIdMapfrom openviking.session.memory.utils.memory_file_utils import MemoryFileUtils+from openviking.session.memory.utils.template_utils import TemplateUtilsfrom openviking.session.memory.utils.uri import render_templatefrom openviking.storage.viking_fs import get_viking_fsfrom openviking.telemetry import tracer@@ -383,7 +384,12 @@ class MemoryUpdater:for op in operations.upsert_operations:for uri in op.uris:uri_memory_type_map[uri] = op.memory_type- await self._vectorize_memories(result, ctx, uri_memory_type_map=uri_memory_type_map)+ await self._vectorize_memories(+ result,+ ctx,+ extract_context=extract_context,+ uri_memory_type_map=uri_memory_type_map,+ )# Apply links to endpoint files not covered by upsert_operationsif operations.resolved_links:@@ -636,19 +642,22 @@ class MemoryUpdater:self,result: MemoryUpdateResult,ctx: RequestContext,- uri_memory_type_map: Dict[str, str],+ extract_context: Any = None,+ uri_memory_type_map: Dict[str, str] = None,) -> None:"""Vectorize written and edited memory files.Args:result: MemoryUpdateResult with written_uris and edited_urisctx: Request context+ extract_context: Extract context for embedding template renderinguri_memory_type_map: Mapping from URI to memory_type"""if not self._vikingdb:logger.debug("VikingDB not available, skipping vectorization")return+ uri_memory_type_map = uri_memory_type_map or {}viking_fs = self._get_viking_fs()request_wait_tracker = get_request_wait_tracker()@@ -673,37 +682,33 @@ class MemoryUpdater:mf = MemoryFileUtils.read(content, uri=uri)abstract = mf.plain_content()-- # Build embedding text from only searchable fields- embedding_parts = []- if abstract:- embedding_parts.append(abstract)+ embedding_text = abstractmemory_type = uri_memory_type_map.get(uri)-if memory_type and self._registry:schema = self._registry.get(memory_type)- if schema:- searchable_fields = {f.name for f in schema.fields if f.searchable}- searchable_data = {}- for field_name in searchable_fields:- if field_name == "content":- continue- field_value = mf.extra_fields.get(field_name)- if field_value is not None:- field_str = (- str(field_value)- if not isinstance(field_value, str)- else field_value+ if schema and schema.embedding_template:+ template_vars = dict(mf.extra_fields)+ template_vars["content"] = abstract+ missing_vars = TemplateUtils.find_missing_variables(+ schema.embedding_template,+ template_vars,+ )+ if missing_vars:+ logger.warning(+ f"Missing embedding template variables for {uri}, falling back to plain content: {sorted(missing_vars)}"+ )+ else:+ try:+ embedding_text = render_template(+ schema.embedding_template,+ template_vars,+ extract_context=extract_context,+ )+ except Exception as e:+ logger.warning(+ f"Failed to render embedding template for {uri}, falling back to plain content: {e}")- if field_str.strip():- searchable_data[field_name] = field_str.strip()- if searchable_data:- import json-- embedding_parts.append(json.dumps(searchable_data, ensure_ascii=False))-- embedding_text = "\n\n".join(embedding_parts) if embedding_parts else abstract# Get parent URIfrom openviking_cli.utils.uri import VikingURIdiff --git a/openviking/session/memory/schema_model_generator.py b/openviking/session/memory/schema_model_generator.pyindex 2a336b2d3..f88dd775f 100644--- a/openviking/session/memory/schema_model_generator.py+++ b/openviking/session/memory/schema_model_generator.py@@ -10,7 +10,6 @@ definitions, with discriminator support for polymorphic fields.import refrom typing import Annotated, Any, Dict, List, Optional, Tuple, Type, Union-import jinja2from pydantic import BaseModel, Field, WithJsonSchema, create_modelfrom pydantic.config import ConfigDict@@ -18,6 +17,7 @@ from openviking.session.memory.dataclass import FaultTolerantBaseModel, MemoryTyfrom openviking.session.memory.memory_isolation_handler import RoleScopefrom openviking.session.memory.merge_op import MergeOp, MergeOpFactoryfrom openviking.session.memory.merge_op.base import FieldType, get_python_type_for_field+from openviking.session.memory.utils.template_utils import TemplateUtilsfrom openviking_cli.utils import get_loggerlogger = get_logger(__name__)@@ -47,7 +47,6 @@ class SchemaModelGenerator:):self.schemas = schemasself._template_context = dict(template_context or {})- self._template_env = jinja2.Environment(autoescape=False)self._model_cache: Dict[str, Type[BaseModel]] = {}self._flat_data_models: Dict[str, Type[BaseModel]] = {}self._union_model: Optional[Type[BaseModel]] = None@@ -58,7 +57,11 @@ class SchemaModelGenerator:return descriptionif "{{" not in description and "{%" not in description and "{#" not in description:return description- return self._template_env.from_string(description).render(**self._template_context)+ return TemplateUtils.render(+ description,+ self._template_context,+ strip=False,+ )def _map_field_type(self, field_type: FieldType) -> Type[Any]:"""Map YAML field type to Python type."""@@ -348,115 +351,3 @@ class SchemaModelGenerator:"""memory_model = self.create_discriminated_union_model()return memory_model.model_json_schema()---class SchemaPromptGenerator:- """- Prompt generator that incorporates schema information into LLM prompts.-- Generates descriptive text about memory types and their fields- based on the YAML schema definitions.- """-- def __init__(- self,- schemas: List[MemoryTypeSchema],- template_context: Optional[Dict[str, Any]] = None,- ):- self.schemas = schemas- self._template_context = dict(template_context or {})- self._template_env = jinja2.Environment(autoescape=False)-- def _render_description(self, description: str) -> str:- if not description:- return description- if "{{" not in description and "{%" not in description and "{#" not in description:- return description- return self._template_env.from_string(description).render(**self._template_context)-- def generate_type_descriptions(self) -> str:- """- Generate descriptions of all memory types.-- Returns:- Formatted string with all memory type descriptions- """- lines = ["## Available Memory Types"]-- for mt in self.schemas:- lines.append(f"\n### {mt.memory_type}")- lines.append(f"{self._render_description(mt.description)}")-- # Add URI format information- if mt.directory or mt.filename_template:- lines.append("\n**URI Format:**")- if mt.directory and mt.filename_template:- lines.append(f"- URI: `{mt.directory}/{mt.filename_template}`")- elif mt.directory:- lines.append(f"- Directory: `{mt.directory}`")- elif mt.filename_template:- lines.append(f"- Filename: `{mt.filename_template}`")-- # Add variable substitution info- lines.append("\n**Variable Substitution:**")- lines.append("- `{{ user_space }}` → 'default'")- lines.append("- `{{ agent_space }}` → 'default'")- if mt.fields:- for field in mt.fields:- lines.append(f"- `{{ {field.name} }}` → use value from fields")-- if mt.fields:- lines.append("\n**Fields:**")- for field in mt.fields:- lines.append(- f"- `{field.name}` ({field.field_type.value}): {self._render_description(field.description)}"- )-- return "\n".join(lines)-- def generate_field_descriptions(self, memory_type: str) -> Optional[str]:- """- Generate descriptions for a specific memory type's fields.-- Args:- memory_type: The memory type to describe-- Returns:- Formatted string with field descriptions, or None if not found- """- mt = next((s for s in self.schemas if s.memory_type == memory_type), None)- if not mt:- return None-- lines = [f"### {mt.memory_type} Fields"]- for field in mt.fields:- lines.append(f"- `{field.name}`: {self._render_description(field.description)}")-- return "\n".join(lines)-- def get_full_prompt_context(self) -> Dict[str, Any]:- """- Get the full prompt context including all schema information.-- Returns:- Dictionary with all prompt context components- """- return {- "type_descriptions": self.generate_type_descriptions(),- "memory_types": [- {- "memory_type": mt.memory_type,- "description": mt.description,- "fields": [- {- "name": f.name,- "type": f.field_type.value,- "description": f.description,- "merge_op": f.merge_op.value,- }- for f in mt.fields- ],- }- for mt in self.schemas- ],- }diff --git a/openviking/session/memory/utils/memory_file_utils.py b/openviking/session/memory/utils/memory_file_utils.pyindex 531ed4268..8a3814639 100644--- a/openviking/session/memory/utils/memory_file_utils.py+++ b/openviking/session/memory/utils/memory_file_utils.py@@ -4,8 +4,8 @@ from datetime import datetimefrom typing import Any, Dict, Optionalfrom openviking.session.memory.dataclass import MemoryFile-from openviking.session.memory.utils.link_renderer import LinkRendererfrom openviking.session.memory.utils.messages import parse_memory_file_with_fields+from openviking.session.memory.utils.uri import render_templatefrom openviking.utils.time_utils import parse_iso_datetime# Regex patterns for MEMORY_FIELDS HTML comment@@ -41,15 +41,9 @@ def _serialize_with_metadata(if content_template:try:- import jinja2- from jinja2 import Environment-- env = Environment(autoescape=False, undefined=jinja2.DebugUndefined)template_vars = metadata.copy()- template_vars["extract_context"] = extract_context-- jinja_template = env.from_string(content_template)- content = jinja_template.render(**template_vars).strip()+ template_vars["content"] = content+ content = render_template(content_template, template_vars, extract_context)except Exception:passdiff --git a/openviking/session/memory/utils/template_utils.py b/openviking/session/memory/utils/template_utils.pynew file mode 100644index 000000000..6fd471bb4--- /dev/null+++ b/openviking/session/memory/utils/template_utils.py@@ -0,0 +1,48 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Template utilities for session memory rendering."""++from __future__ import annotations++from typing import Any, Iterable, Mapping++import jinja2+from jinja2 import meta+++class TemplateUtils:+ @staticmethod+ def render(+ template: str,+ fields: Mapping[str, Any],+ extract_context: Any = None,+ *,+ debug_undefined: bool = False,+ keep_trailing_newline: bool = False,+ strip: bool = True,+ ) -> str:+ env = jinja2.Environment(+ autoescape=False,+ undefined=jinja2.DebugUndefined if debug_undefined else jinja2.Undefined,+ keep_trailing_newline=keep_trailing_newline,+ )+ template_vars = dict(fields)+ template_vars["extract_context"] = extract_context+ rendered = env.from_string(template).render(**template_vars)+ return rendered.strip() if strip else rendered++ @staticmethod+ def find_missing_variables(+ template: str,+ fields: Mapping[str, Any],+ *,+ ignored_variables: Iterable[str] | None = None,+ ) -> set[str]:+ parsed_template = jinja2.Environment(autoescape=False).parse(template)+ ignored = set(ignored_variables or ())+ return (+ meta.find_undeclared_variables(parsed_template)+ - set(fields)+ - ignored+ - {"extract_context"}+ )diff --git a/openviking/session/memory/utils/uri.py b/openviking/session/memory/utils/uri.pyindex a5a795f89..fe693a5e9 100644--- a/openviking/session/memory/utils/uri.py+++ b/openviking/session/memory/utils/uri.py@@ -9,20 +9,9 @@ from __future__ import annotationsimport refrom typing import Any, Dict, Set-import jinja2-from openviking.session.memory.dataclass import MemoryTypeSchemafrom openviking.session.memory.utils.model import model_to_dict---def _render_jinja_template(template: str, context: Dict[str, Any]) -> str:- """Render a Jinja2 template with the given context."""- env = jinja2.Environment(- autoescape=False,- keep_trailing_newline=True,- )- jinja_template = env.from_string(template)- return jinja_template.render(**context)+from openviking.session.memory.utils.template_utils import TemplateUtilsdef render_template(@@ -44,17 +33,12 @@ def render_template(Returns:Rendered template string"""- # 创建 Jinja2 环境,允许未定义的变量(打印警告但不报错)- env = jinja2.Environment(autoescape=False, undefined=jinja2.DebugUndefined)-- # 创建模板变量- template_vars = fields.copy()- # 始终传入 extract_context,即使是 None,避免模板中访问时 undefined- template_vars["extract_context"] = extract_context-- # 渲染模板- jinja_template = env.from_string(template)- return jinja_template.render(**template_vars).strip()+ return TemplateUtils.render(+ template,+ fields,+ extract_context=extract_context,+ debug_undefined=True,+ )def generate_uri(diff --git a/openviking/telemetry/tracer.py b/openviking/telemetry/tracer.pyindex 784f6b4d0..bca47a37a 100644--- a/openviking/telemetry/tracer.py+++ b/openviking/telemetry/tracer.py@@ -172,7 +172,7 @@ def _init_asyncio_instrumentation() -> None:from opentelemetry.instrumentation.asyncio import AsyncioInstrumentorAsyncioInstrumentor().instrument()- logger.info("[TRACER] initialized AsyncioInstrumentor")+ logger.debug("[TRACER] initialized AsyncioInstrumentor")except ImportError:logger.warning("[TRACER] opentelemetry-instrumentation-asyncio not installed")except Exception as e:@@ -269,7 +269,7 @@ def init_tracer(# Initialize asyncio instrumentation to create child spans for create_task_init_asyncio_instrumentation()- logger.info(+ logger.debug("[TRACER] initialized with service_name=%s, protocol=%s, endpoint=%s",service_name,protocol,diff --git a/openviking_cli/utils/config/memory_config.py b/openviking_cli/utils/config/memory_config.pyindex f46ff2fdf..ace58206e 100644--- a/openviking_cli/utils/config/memory_config.py+++ b/openviking_cli/utils/config/memory_config.py@@ -91,7 +91,7 @@ class MemoryConfig(BaseModel):"default."),)- enable_role_id_memory_isolate: bool = Field(+ role_id_memory_isolation_enabled: bool = Field(default=False,description=("When enabled, memory extraction uses role_id from messages to determine "diff --git a/tests/session/memory/test_compressor_v2.py b/tests/session/memory/test_compressor_v2.pyindex 01e1a0a66..3f5e9e2b7 100644--- a/tests/session/memory/test_compressor_v2.py+++ b/tests/session/memory/test_compressor_v2.py@@ -597,7 +597,7 @@ class TestCompressorV2:config = SimpleNamespace(vlm=SimpleNamespace(get_vlm_instance=lambda: object()),memory=SimpleNamespace(- enable_role_id_memory_isolate=False,+ role_id_memory_isolation_enabled=False,v2_lock_max_retries=1,v2_lock_retry_interval_seconds=0.0,),diff --git a/tests/session/memory/test_memory_isolation_handler.py b/tests/session/memory/test_memory_isolation_handler.pyindex 1b5c480d2..8b88cc969 100644--- a/tests/session/memory/test_memory_isolation_handler.py+++ b/tests/session/memory/test_memory_isolation_handler.py@@ -236,33 +236,34 @@ class TestFillRoleIds:class TestPrepareMessages:- """Tests for prepare_messages with enable_role_id_memory_isolate toggle."""+ """Tests for prepare_messages with role_id_memory_isolation_enabled toggle."""@patch("openviking.session.memory.memory_isolation_handler.get_openviking_config")- def test_prepare_messages_disabled_clears_role_ids(self, mock_config):- """开关关闭时,prepare_messages 清空所有 message 的 role_id。"""+ def test_prepare_messages_disabled_fills_missing_role_ids(self, mock_config):+ """开关关闭时,prepare_messages 用登录身份回填缺失的 role_id。"""mock_memory_config = MagicMock()- mock_memory_config.enable_role_id_memory_isolate = False+ mock_memory_config.role_id_memory_isolation_enabled = Falsemock_config.return_value.memory = mock_memory_configctx = create_ctx(user_id="login_user", agent_id="login_agent")messages = [- create_message("user", "user_a", "Hello"),- create_message("assistant", "agent_a", "Hi"),+ create_message("user", None, "Hello"),+ create_message("assistant", None, "Hi"),create_message("user", "user_b", "Hey"),]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)handler.prepare_messages()- for msg in messages:- assert msg.role_id is None+ assert messages[0].role_id == "login_user"+ assert messages[1].role_id == "login_agent"+ assert messages[2].role_id == "user_b"@patch("openviking.session.memory.memory_isolation_handler.get_openviking_config")def test_prepare_messages_enabled_keeps_role_ids(self, mock_config):"""开关开启时,prepare_messages 不修改 role_id。"""mock_memory_config = MagicMock()- mock_memory_config.enable_role_id_memory_isolate = True+ mock_memory_config.role_id_memory_isolation_enabled = Truemock_config.return_value.memory = mock_memory_configctx = create_ctx(user_id="login_user", agent_id="login_agent")@@ -278,16 +279,16 @@ class TestPrepareMessages:assert messages[1].role_id == "agent_a"@patch("openviking.session.memory.memory_isolation_handler.get_openviking_config")- def test_get_read_scope_with_prepare_disabled(self, mock_config):- """开关关闭时,get_read_scope 只返回登录用户(因为 role_id 被清空)。"""+ def test_get_read_scope_with_prepare_disabled_uses_ctx_for_missing_role_ids(self, mock_config):+ """开关关闭时,get_read_scope 对缺失 role_id 的消息回退到登录身份。"""mock_memory_config = MagicMock()- mock_memory_config.enable_role_id_memory_isolate = False+ mock_memory_config.role_id_memory_isolation_enabled = Falsemock_config.return_value.memory = mock_memory_configctx = create_ctx(user_id="login_user", agent_id="login_agent")messages = [- create_message("user", "user_a", "Hello"),- create_message("assistant", "agent_a", "Hi"),+ create_message("user", None, "Hello"),+ create_message("assistant", None, "Hi"),]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)@@ -301,7 +302,7 @@ class TestPrepareMessages:def test_get_read_scope_with_prepare_enabled(self, mock_config):"""开关开启时,get_read_scope 从 message role_id 提取参与者。"""mock_memory_config = MagicMock()- mock_memory_config.enable_role_id_memory_isolate = True+ mock_memory_config.role_id_memory_isolation_enabled = Truemock_config.return_value.memory = mock_memory_configctx = create_ctx(user_id="login_user", agent_id="login_agent")@@ -318,19 +319,19 @@ class TestPrepareMessages:assert set(scope.agent_ids) == {"agent_a"}@patch("openviking.session.memory.memory_isolation_handler.get_openviking_config")- def test_prepare_messages_no_config(self, mock_config):- """没有 memory 配置时,默认关闭,清空 role_id。"""+ def test_prepare_messages_no_config_fills_missing_role_ids(self, mock_config):+ """没有 memory 配置时,默认关闭,并用登录身份回填缺失的 role_id。"""mock_config.return_value.memory = Nonectx = create_ctx(user_id="login_user", agent_id="login_agent")messages = [- create_message("user", "user_a", "Hello"),+ create_message("user", None, "Hello"),]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)handler.prepare_messages()- assert messages[0].role_id is None+ assert messages[0].role_id == "login_user"class TestCalculateMemoryUris:diff --git a/tests/session/memory/test_template_utils.py b/tests/session/memory/test_template_utils.pynew file mode 100644index 000000000..912347c3d--- /dev/null+++ b/tests/session/memory/test_template_utils.py@@ -0,0 +1,32 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0++from types import SimpleNamespace++from openviking.session.memory.utils.template_utils import TemplateUtils+++class TestTemplateUtils:+ def test_render_supports_extract_context(self):+ extract_context = SimpleNamespace(get_year=lambda ranges: "2026")++ rendered = TemplateUtils.render(+ " {{ title }} {{ extract_context.get_year(ranges) }} ",+ {"title": "Trip", "ranges": "0-1"},+ extract_context=extract_context,+ )++ assert rendered == "Trip 2026"++ def test_find_missing_variables_ignores_extract_context(self):+ missing = TemplateUtils.find_missing_variables(+ "{{ missing_field }} {{ extract_context.get_year(ranges) }} {{ content }}",+ {"content": "Trip summary", "ranges": "0-1"},+ )++ assert missing == {"missing_field"}++ def test_render_plain_text_without_template_syntax(self):+ rendered = TemplateUtils.render("plain text", {"unused": "value"})++ assert rendered == "plain text"diff --git a/tests/test_config_loader.py b/tests/test_config_loader.pyindex 4aa9189bb..fee2889a0 100644--- a/tests/test_config_loader.py+++ b/tests/test_config_loader.py@@ -188,6 +188,21 @@ def test_openviking_config_warns_when_agent_scope_mode_is_configured(monkeypatchOpenVikingConfigSingleton.reset_instance()+def test_openviking_config_accepts_role_id_memory_isolation_enabled(monkeypatch):+ monkeypatch.setenv(OPENVIKING_CONFIG_ENV, "/tmp/codex-no-config.json")++ from openviking_cli.utils.config.open_viking_config import (+ OpenVikingConfig,+ OpenVikingConfigSingleton,+ )++ config = OpenVikingConfig.from_dict({"memory": {"role_id_memory_isolation_enabled": True}})++ assert config.memory.role_id_memory_isolation_enabled is True++ OpenVikingConfigSingleton.reset_instance()++def test_openviking_config_memory_experimental_switch_defaults_agent_memory(monkeypatch):monkeypatch.setenv(OPENVIKING_CONFIG_ENV, "/tmp/codex-no-config.json")@@ -228,7 +243,7 @@ def test_openviking_config_retrieval_hotness_alpha_defaults_to_zero(monkeypatch)config = OpenVikingConfig.from_dict({})assert config.retrieval.hotness_alpha == 0.0- assert config.retrieval.score_propagation_alpha == 0.5+ assert config.retrieval.score_propagation_alpha == 1.0assert config.storage.transaction.redo_recovery_enabled is TrueOpenVikingConfigSingleton.reset_instance()@@ -323,8 +338,11 @@ def test_require_config_missing_message_uses_openviking_ai_docs(tmp_path, monkeydef test_load_server_config_missing_message_uses_openviking_ai_docs(tmp_path, monkeypatch):import openviking.server.config as server_config+ import openviking_cli.utils.config.config_loader as loadermonkeypatch.delenv(OPENVIKING_CONFIG_ENV, raising=False)+ monkeypatch.setattr(loader, "DEFAULT_CONFIG_DIR", tmp_path / "user")+ monkeypatch.setattr(loader, "SYSTEM_CONFIG_DIR", tmp_path / "system")monkeypatch.setattr(server_config, "DEFAULT_CONFIG_DIR", tmp_path / "user")monkeypatch.setattr(server_config, "SYSTEM_CONFIG_DIR", tmp_path / "system")@@ -333,10 +351,13 @@ def test_load_server_config_missing_message_uses_openviking_ai_docs(tmp_path, modef test_openviking_config_singleton_missing_message_uses_openviking_ai_docs(tmp_path, monkeypatch):+ import openviking_cli.utils.config.config_loader as loaderimport openviking_cli.utils.config.open_viking_config as config_modulefrom openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingletonmonkeypatch.delenv(OPENVIKING_CONFIG_ENV, raising=False)+ monkeypatch.setattr(loader, "DEFAULT_CONFIG_DIR", tmp_path / "user")+ monkeypatch.setattr(loader, "SYSTEM_CONFIG_DIR", tmp_path / "system")monkeypatch.setattr(config_module, "DEFAULT_CONFIG_DIR", tmp_path / "user")monkeypatch.setattr(config_module, "SYSTEM_CONFIG_DIR", tmp_path / "system")@@ -351,10 +372,13 @@ def test_openviking_config_singleton_missing_message_uses_openviking_ai_docs(tmpdef test_openviking_config_singleton_initialize_missing_message_uses_openviking_ai_docs(tmp_path, monkeypatch):+ import openviking_cli.utils.config.config_loader as loaderimport openviking_cli.utils.config.open_viking_config as config_modulefrom openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingletonmonkeypatch.delenv(OPENVIKING_CONFIG_ENV, raising=False)+ monkeypatch.setattr(loader, "DEFAULT_CONFIG_DIR", tmp_path / "user")+ monkeypatch.setattr(loader, "SYSTEM_CONFIG_DIR", tmp_path / "system")monkeypatch.setattr(config_module, "DEFAULT_CONFIG_DIR", tmp_path / "user")monkeypatch.setattr(config_module, "SYSTEM_CONFIG_DIR", tmp_path / "system")diff --git a/tests/unit/session/memory/test_embedding_template.py b/tests/unit/session/memory/test_embedding_template.pynew file mode 100644index 000000000..351de682f--- /dev/null+++ b/tests/unit/session/memory/test_embedding_template.py@@ -0,0 +1,360 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0++from types import SimpleNamespace+from unittest.mock import AsyncMock, Mock, patch++import pytest++from openviking.prompts.manager import PromptManager+from openviking.session.memory.dataclass import MemoryField, MemoryFile+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry+from openviking.session.memory.memory_updater import MemoryUpdater, MemoryUpdateResult+from openviking.session.memory.merge_op.base import FieldType+from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils+from openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverter+++class TestMemoryFieldSchema:+ def test_memory_field_no_longer_has_searchable(self):+ field = MemoryField(name="test", field_type=FieldType.STRING, description="test")+ assert not hasattr(field, "searchable")+++class TestEmbeddingTemplateYamlParsing:+ @pytest.fixture(autouse=True)+ def setup(self):+ memory_dir = PromptManager._get_bundled_templates_dir() / "memory"+ self.registry = MemoryTypeRegistry(load_schemas=False)+ self.registry.load_from_yaml(str(memory_dir / "events.yaml"))+ self.registry.load_from_yaml(str(memory_dir / "preferences.yaml"))+ self.registry.load_from_yaml(str(memory_dir / "entities.yaml"))++ def test_events_exposes_embedding_template(self):+ schema = self.registry.get("events")+ assert schema.embedding_template == "{{ event_name }}\n\n{{ goal }}\n\n{{ content }}"++ def test_preferences_exposes_embedding_template(self):+ schema = self.registry.get("preferences")+ assert schema.embedding_template == "{{ user }}\n\n{{ topic }}\n\n{{ content }}"++ def test_entities_exposes_embedding_template(self):+ schema = self.registry.get("entities")+ assert schema.embedding_template == "{{ category }}\n\n{{ name }}\n\n{{ content }}"+++class TestContentTemplateRendering:+ def test_content_template_can_access_content_extra_fields_and_extract_context(self):+ memory_file = MemoryFile(+ content="Body content",+ extra_fields={"title": "Road Trip", "ranges": "0-1"},+ )+ extract_context = SimpleNamespace(get_year=lambda ranges: "2026")++ rendered = MemoryFileUtils.write(+ memory_file,+ content_template="{{ title }} | {{ content }} | {{ extract_context.get_year(ranges) }}",+ extract_context=extract_context,+ )++ assert rendered.startswith("Road Trip | Body content | 2026")+++class TestEmbeddingTextConstruction:+ @pytest.mark.asyncio+ async def test_logs_final_embedding_text_before_vectorization(self):+ registry = MemoryTypeRegistry(load_schemas=False)+ registry._types["entities"] = registry._parse_memory_type(+ {+ "memory_type": "entities",+ "directory": "viking://user/{{ user_space }}/memories/entities",+ "filename_template": "{{ name }}.md",+ "embedding_template": "{{ category }} -> {{ name }} -> {{ content }}",+ "fields": [+ {"name": "category", "type": "string"},+ {"name": "name", "type": "string"},+ {"name": "content", "type": "string"},+ ],+ }+ )++ updater = MemoryUpdater(registry=registry, vikingdb=Mock())+ updater._viking_fs = Mock()+ updater._viking_fs.read_file = AsyncMock(+ return_value=MemoryFileUtils.write(+ MemoryFile(+ uri="viking://user/alice/memories/entities/person/alice.md",+ memory_type="entities",+ content="Plain body",+ extra_fields={"category": "person", "name": "alice"},+ )+ )+ )+ updater._vikingdb.enqueue_embedding_msg = AsyncMock(return_value=True)++ result = MemoryUpdateResult()+ result.add_written("viking://user/alice/memories/entities/person/alice.md")+ ctx = SimpleNamespace(user=None, account_id="default")++ with (+ patch.object(EmbeddingMsgConverter, "from_context") as mock_from_context,+ patch("openviking.session.memory.memory_updater.logger.error") as mock_logger_error,+ ):+ mock_from_context.side_effect = lambda context: SimpleNamespace(+ telemetry_id=None, id="msg-1", message=context.get_vectorization_text()+ )+ await updater._vectorize_memories(+ result,+ ctx,+ extract_context=None,+ uri_memory_type_map={+ "viking://user/alice/memories/entities/person/alice.md": "entities"+ },+ )++ mock_logger_error.assert_not_called()++ @pytest.mark.asyncio+ async def test_embedding_template_overrides_plain_content(self):+ registry = MemoryTypeRegistry(load_schemas=False)+ registry._types["entities"] = registry._parse_memory_type(+ {+ "memory_type": "entities",+ "directory": "viking://user/{{ user_space }}/memories/entities",+ "filename_template": "{{ name }}.md",+ "embedding_template": "{{ category }} -> {{ name }} -> {{ content }}",+ "fields": [+ {"name": "category", "type": "string"},+ {"name": "name", "type": "string"},+ {"name": "content", "type": "string"},+ ],+ }+ )++ updater = MemoryUpdater(registry=registry, vikingdb=Mock())+ updater._viking_fs = Mock()+ updater._viking_fs.read_file = AsyncMock(+ return_value=MemoryFileUtils.write(+ MemoryFile(+ uri="viking://user/alice/memories/entities/person/alice.md",+ memory_type="entities",+ content="Plain body",+ extra_fields={"category": "person", "name": "alice"},+ )+ )+ )+ updater._vikingdb.enqueue_embedding_msg = AsyncMock(return_value=True)++ result = MemoryUpdateResult()+ result.add_written("viking://user/alice/memories/entities/person/alice.md")+ ctx = SimpleNamespace(user=None, account_id="default")++ with patch.object(EmbeddingMsgConverter, "from_context") as mock_from_context:+ mock_from_context.side_effect = lambda context: SimpleNamespace(+ telemetry_id=None, id="msg-1", message=context.get_vectorization_text()+ )+ await updater._vectorize_memories(+ result,+ ctx,+ extract_context=None,+ uri_memory_type_map={+ "viking://user/alice/memories/entities/person/alice.md": "entities"+ },+ )++ vector_text = mock_from_context.call_args[0][0].get_vectorization_text()+ assert vector_text == "person -> alice -> Plain body"++ @pytest.mark.asyncio+ async def test_plain_content_fallback_still_works(self):+ registry = MemoryTypeRegistry(load_schemas=False)+ registry._types["notes"] = registry._parse_memory_type(+ {+ "memory_type": "notes",+ "directory": "viking://user/{{ user_space }}/memories/notes",+ "filename_template": "{{ slug }}.md",+ "fields": [+ {"name": "slug", "type": "string"},+ {"name": "content", "type": "string"},+ ],+ }+ )++ updater = MemoryUpdater(registry=registry, vikingdb=Mock())+ updater._viking_fs = Mock()+ updater._viking_fs.read_file = AsyncMock(+ return_value=MemoryFileUtils.write(+ MemoryFile(+ uri="viking://user/alice/memories/notes/example.md",+ memory_type="notes",+ content="Fallback plain body",+ extra_fields={"slug": "example"},+ )+ )+ )+ updater._vikingdb.enqueue_embedding_msg = AsyncMock(return_value=True)++ result = MemoryUpdateResult()+ result.add_written("viking://user/alice/memories/notes/example.md")+ ctx = SimpleNamespace(user=None, account_id="default")++ with patch.object(EmbeddingMsgConverter, "from_context") as mock_from_context:+ mock_from_context.side_effect = lambda context: SimpleNamespace(+ telemetry_id=None, id="msg-1", message=context.get_vectorization_text()+ )+ await updater._vectorize_memories(+ result,+ ctx,+ extract_context=None,+ uri_memory_type_map={"viking://user/alice/memories/notes/example.md": "notes"},+ )++ vector_text = mock_from_context.call_args[0][0].get_vectorization_text()+ assert vector_text == "Fallback plain body"++ @pytest.mark.asyncio+ async def test_embedding_template_receives_extract_context(self):+ registry = MemoryTypeRegistry(load_schemas=False)+ registry._types["events"] = registry._parse_memory_type(+ {+ "memory_type": "events",+ "directory": "viking://user/{{ user_space }}/memories/events",+ "filename_template": "{{ event_name }}.md",+ "embedding_template": "{{ extract_context.get_year(ranges) }} {{ content }}",+ "fields": [+ {"name": "event_name", "type": "string"},+ {"name": "ranges", "type": "string"},+ {"name": "content", "type": "string"},+ ],+ }+ )++ updater = MemoryUpdater(registry=registry, vikingdb=Mock())+ updater._viking_fs = Mock()+ updater._viking_fs.read_file = AsyncMock(+ return_value=MemoryFileUtils.write(+ MemoryFile(+ uri="viking://user/alice/memories/events/trip.md",+ memory_type="events",+ content="Trip summary",+ extra_fields={"event_name": "trip", "ranges": "0-1"},+ )+ )+ )+ updater._vikingdb.enqueue_embedding_msg = AsyncMock(return_value=True)++ result = MemoryUpdateResult()+ result.add_written("viking://user/alice/memories/events/trip.md")+ ctx = SimpleNamespace(user=None, account_id="default")+ extract_context = SimpleNamespace(get_year=lambda ranges: "2026")++ with patch.object(EmbeddingMsgConverter, "from_context") as mock_from_context:+ mock_from_context.side_effect = lambda context: SimpleNamespace(+ telemetry_id=None, id="msg-1", message=context.get_vectorization_text()+ )+ await updater._vectorize_memories(+ result,+ ctx,+ extract_context=extract_context,+ uri_memory_type_map={"viking://user/alice/memories/events/trip.md": "events"},+ )++ vector_text = mock_from_context.call_args[0][0].get_vectorization_text()+ assert vector_text == "2026 Trip summary"++ @pytest.mark.asyncio+ async def test_embedding_template_render_failure_falls_back_to_plain_content(self):+ registry = MemoryTypeRegistry(load_schemas=False)+ registry._types["events"] = registry._parse_memory_type(+ {+ "memory_type": "events",+ "directory": "viking://user/{{ user_space }}/memories/events",+ "filename_template": "{{ event_name }}.md",+ "embedding_template": "{{ extract_context.get_year(ranges) }} {{ content }}",+ "fields": [+ {"name": "event_name", "type": "string"},+ {"name": "ranges", "type": "string"},+ {"name": "content", "type": "string"},+ ],+ }+ )++ updater = MemoryUpdater(registry=registry, vikingdb=Mock())+ updater._viking_fs = Mock()+ updater._viking_fs.read_file = AsyncMock(+ return_value=MemoryFileUtils.write(+ MemoryFile(+ uri="viking://user/alice/memories/events/trip.md",+ memory_type="events",+ content="Trip summary",+ extra_fields={"event_name": "trip", "ranges": "0-1"},+ )+ )+ )+ updater._vikingdb.enqueue_embedding_msg = AsyncMock(return_value=True)++ result = MemoryUpdateResult()+ result.add_written("viking://user/alice/memories/events/trip.md")+ ctx = SimpleNamespace(user=None, account_id="default")++ with patch.object(EmbeddingMsgConverter, "from_context") as mock_from_context:+ mock_from_context.side_effect = lambda context: SimpleNamespace(+ telemetry_id=None, id="msg-1", message=context.get_vectorization_text()+ )+ await updater._vectorize_memories(+ result,+ ctx,+ extract_context=None,+ uri_memory_type_map={"viking://user/alice/memories/events/trip.md": "events"},+ )++ vector_text = mock_from_context.call_args[0][0].get_vectorization_text()+ assert vector_text == "Trip summary"++ @pytest.mark.asyncio+ async def test_embedding_template_missing_variable_falls_back_to_plain_content(self):+ registry = MemoryTypeRegistry(load_schemas=False)+ registry._types["events"] = registry._parse_memory_type(+ {+ "memory_type": "events",+ "directory": "viking://user/{{ user_space }}/memories/events",+ "filename_template": "{{ event_name }}.md",+ "embedding_template": "{{ missing_field }} {{ content }}",+ "fields": [+ {"name": "event_name", "type": "string"},+ {"name": "content", "type": "string"},+ ],+ }+ )++ updater = MemoryUpdater(registry=registry, vikingdb=Mock())+ updater._viking_fs = Mock()+ updater._viking_fs.read_file = AsyncMock(+ return_value=MemoryFileUtils.write(+ MemoryFile(+ uri="viking://user/alice/memories/events/trip.md",+ memory_type="events",+ content="Trip summary",+ extra_fields={"event_name": "trip"},+ )+ )+ )+ updater._vikingdb.enqueue_embedding_msg = AsyncMock(return_value=True)++ result = MemoryUpdateResult()+ result.add_written("viking://user/alice/memories/events/trip.md")+ ctx = SimpleNamespace(user=None, account_id="default")++ with patch.object(EmbeddingMsgConverter, "from_context") as mock_from_context:+ mock_from_context.side_effect = lambda context: SimpleNamespace(+ telemetry_id=None, id="msg-1", message=context.get_vectorization_text()+ )+ await updater._vectorize_memories(+ result,+ ctx,+ extract_context=None,+ uri_memory_type_map={"viking://user/alice/memories/events/trip.md": "events"},+ )++ vector_text = mock_from_context.call_args[0][0].get_vectorization_text()+ assert vector_text == "Trip summary"diff --git a/tests/unit/session/memory/test_searchable.py b/tests/unit/session/memory/test_searchable.pydeleted file mode 100644index 59fd4abfd..000000000--- a/tests/unit/session/memory/test_searchable.py+++ /dev/null@@ -1,154 +0,0 @@-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.-# SPDX-License-Identifier: AGPL-3.0--import pytest--from openviking.session.memory.dataclass import MemoryField-from openviking.session.memory.merge_op.base import FieldType-from openviking.session.memory.memory_type_registry import MemoryTypeRegistry---class TestMemoryFieldSearchable:- def test_default_is_false(self):- field = MemoryField(name="test", field_type=FieldType.STRING, description="test")- assert field.searchable is False-- def test_explicit_true(self):- field = MemoryField(- name="content", field_type=FieldType.STRING, description="desc", searchable=True- )- assert field.searchable is True-- def test_explicit_false(self):- field = MemoryField(- name="call_count", field_type=FieldType.INT64, description="count", searchable=False- )- assert field.searchable is False---class TestSearchableYamlParsing:- @pytest.fixture(autouse=True)- def setup(self):- self.registry = MemoryTypeRegistry()-- def test_events_searchable_fields(self):- schema = self.registry.get("events")- searchable = {f.name for f in schema.fields if f.searchable}- assert searchable == {"event_name", "goal", "summary"}-- def test_tools_searchable_fields(self):- schema = self.registry.get("tools")- searchable = {f.name for f in schema.fields if f.searchable}- assert searchable == set() # all rendered in content_template-- def test_entities_searchable_fields(self):- schema = self.registry.get("entities")- searchable = {f.name for f in schema.fields if f.searchable}- assert searchable == {"category", "name"}-- def test_preferences_searchable_fields(self):- schema = self.registry.get("preferences")- searchable = {f.name for f in schema.fields if f.searchable}- assert searchable == {"user", "topic"}-- def test_profile_searchable_fields(self):- schema = self.registry.get("profile")- searchable = {f.name for f in schema.fields if f.searchable}- assert searchable == set()-- def test_soul_searchable_fields(self):- schema = self.registry.get("soul")- searchable = {f.name for f in schema.fields if f.searchable}- assert searchable == set() # all rendered in content_template-- def test_skills_searchable_fields(self):- schema = self.registry.get("skills")- searchable = {f.name for f in schema.fields if f.searchable}- assert searchable == set() # all rendered in content_template---class TestEmbeddingTextConstruction:- """Test that embedding text only includes searchable fields in JSON format."""-- def test_searchable_fields_as_json(self):- parsed = {- "content": "Body content here",- "tool_name": "web_search",- "call_count": "42",- "when_to_use": "When you need web info",- }- abstract = parsed.get("content", "")- searchable_fields = {"when_to_use"}- embedding_parts = []- if abstract:- embedding_parts.append(abstract)- searchable_data = {}- for field_name in searchable_fields:- if field_name == "content":- continue- field_value = parsed.get(field_name)- if field_value is not None:- field_str = str(field_value) if not isinstance(field_value, str) else field_value- if field_str.strip():- searchable_data[field_name] = field_str.strip()- if searchable_data:- import json-- embedding_parts.append(json.dumps(searchable_data, ensure_ascii=False))- embedding_text = "\n\n".join(embedding_parts)- assert "web_search" not in embedding_text- assert "42" not in embedding_text- assert '"when_to_use": "When you need web info"' in embedding_text- assert "Body content here" in embedding_text-- def test_excludes_links_and_backlinks(self):- parsed = {- "content": "Body content",- "summary": "A summary",- "links": [{"from_uri": "a", "to_uri": "b"}],- "backlinks": [],- }- searchable_fields = {"summary"}- embedding_parts = []- abstract = parsed.get("content", "")- if abstract:- embedding_parts.append(abstract)- searchable_data = {}- for field_name in searchable_fields:- if field_name == "content":- continue- field_value = parsed.get(field_name)- if field_value is not None:- field_str = str(field_value) if not isinstance(field_value, str) else field_value- if field_str.strip():- searchable_data[field_name] = field_str.strip()- if searchable_data:- import json-- embedding_parts.append(json.dumps(searchable_data, ensure_ascii=False))- embedding_text = "\n\n".join(embedding_parts)- assert "links" not in embedding_text- assert "from_uri" not in embedding_text-- def test_no_searchable_data_no_json_appended(self):- parsed = {- "content": "Body content only",- "event_name": "road_trip",- "ranges": "0-5",- }- abstract = parsed.get("content", "")- searchable_fields = set() # no searchable fields- embedding_parts = []- if abstract:- embedding_parts.append(abstract)- searchable_data = {}- for field_name in searchable_fields:- if field_name == "content":- continue- if searchable_data:- import json-- embedding_parts.append(json.dumps(searchable_data, ensure_ascii=False))- embedding_text = "\n\n".join(embedding_parts)- assert embedding_text == "Body content only"- assert "{" not in embedding_textdiff --git a/uv.lock b/uv.lockindex 58f2e6436..2a87ad92f 100644--- a/uv.lock+++ b/uv.lock@@ -3755,7 +3755,7 @@ requires-dist = [{ name = "langgraph", marker = "extra == 'langgraph'", specifier = ">=1.0.0,<2.0.0" },{ name = "lark-oapi", specifier = ">=1.5.3" },{ name = "lark-oapi", marker = "extra == 'bot-feishu'", specifier = ">=1.0.0" },- { name = "litellm", specifier = ">=1.83.7,<1.84.1" },+ { name = "litellm", specifier = ">=1.83.7,<1.85.2" },{ name = "llama-cpp-python", marker = "extra == 'local-embed'", specifier = ">=0.3.0" },{ name = "loguru", specifier = ">=0.7.3" },{ name = "markdownify", specifier = ">=0.11.0" },