Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

Feat/searchable template (#2193)

chenjw82225006fb92
diff --git a/examples/ov.conf.example b/examples/ov.conf.example
index 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.yaml
index 2990d70b5..2e4c5c0ea 100644
--- a/openviking/prompts/templates/memory/entities.yaml
+++ b/openviking/prompts/templates/memory/entities.yaml
@@ -1,11 +1,17 @@
memory_type: entities
description: |
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: name
type: string
description: |
- Entity name in Chinese or English. If English, use lowercase with underscores, max 3 words.
merge_op: immutable
- searchable: true
- name: content
type: string
diff --git a/openviking/prompts/templates/memory/events.yaml b/openviking/prompts/templates/memory/events.yaml
index 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: goal
type: string
description: |
Summarize the purpose of the content in 5 words or less
- searchable: true
- name: summary
type: string
description: |
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: ranges
type: string
diff --git a/openviking/prompts/templates/memory/preferences.yaml b/openviking/prompts/templates/memory/preferences.yaml
index 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 owner
merge_op: immutable
- searchable: true
- name: topic
type: 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: content
type: string
diff --git a/openviking/session/memory/__init__.py b/openviking/session/memory/__init__.py
index 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 MemoryTypeRegistry
from openviking.session.memory.memory_updater import MemoryUpdater, MemoryUpdateResult
from 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 SchemaModelGenerator
from 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.py
index 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 their
source_trajectories as grounding material.
"""
-import jinja2
from typing import Any, Dict, List, Optional
from openviking.core.namespace import to_agent_space, to_user_space
-from openviking.server.identity import RequestContext, ToolContext
+from openviking.server.identity import RequestContext
from openviking.session.memory.dataclass import MemoryFile
from openviking.session.memory.session_extract_context_provider import (
SessionExtractContextProvider,
)
from openviking.session.memory.tools import add_tool_call_pair_to_messages
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
+from openviking.session.memory.utils.template_utils import TemplateUtils
from openviking.storage.viking_fs import VikingFS
from openviking.telemetry import tracer
from 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.py
index 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.py
index 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 MemoryIsolationHandler
from 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 SchemaModelGenerator
from 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 json
schema_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 Rules
diff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.py
index 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 = ctx
self._extract_context = extract_context
config = 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:
return
messages = 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.py
index 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 PromptManager
from openviking.session.memory.dataclass import MemoryField, MemoryTypeSchema
from openviking.session.memory.merge_op import MergeOp
from openviking.session.memory.merge_op.base import FieldType
+from openviking.session.memory.utils.template_utils import TemplateUtils
from openviking_cli.utils import get_logger
logger = 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_fs
logger = 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 schema
try:
- 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:
continue
diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.py
index 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 MemoryTypeRegistry
from openviking.session.memory.merge_op import MergeOpFactory
from openviking.session.memory.page_id_map import PageIdMap
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
+from openviking.session.memory.utils.template_utils import TemplateUtils
from openviking.session.memory.utils.uri import render_template
from openviking.storage.viking_fs import get_viking_fs
from 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_operations
if 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_uris
ctx: Request context
+ extract_context: Extract context for embedding template rendering
uri_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 = abstract
memory_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 URI
from openviking_cli.utils.uri import VikingURI
diff --git a/openviking/session/memory/schema_model_generator.py b/openviking/session/memory/schema_model_generator.py
index 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 re
from typing import Annotated, Any, Dict, List, Optional, Tuple, Type, Union
-import jinja2
from pydantic import BaseModel, Field, WithJsonSchema, create_model
from pydantic.config import ConfigDict
@@ -18,6 +17,7 @@ from openviking.session.memory.dataclass import FaultTolerantBaseModel, MemoryTy
from openviking.session.memory.memory_isolation_handler import RoleScope
from openviking.session.memory.merge_op import MergeOp, MergeOpFactory
from openviking.session.memory.merge_op.base import FieldType, get_python_type_for_field
+from openviking.session.memory.utils.template_utils import TemplateUtils
from openviking_cli.utils import get_logger
logger = get_logger(__name__)
@@ -47,7 +47,6 @@ class SchemaModelGenerator:
):
self.schemas = schemas
self._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 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)
+ 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.py
index 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 datetime
from typing import Any, Dict, Optional
from openviking.session.memory.dataclass import MemoryFile
-from openviking.session.memory.utils.link_renderer import LinkRenderer
from openviking.session.memory.utils.messages import parse_memory_file_with_fields
+from openviking.session.memory.utils.uri import render_template
from 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:
pass
diff --git a/openviking/session/memory/utils/template_utils.py b/openviking/session/memory/utils/template_utils.py
new file mode 100644
index 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.py
index a5a795f89..fe693a5e9 100644
--- a/openviking/session/memory/utils/uri.py
+++ b/openviking/session/memory/utils/uri.py
@@ -9,20 +9,9 @@ from __future__ import annotations
import re
from typing import Any, Dict, Set
-import jinja2
-
from openviking.session.memory.dataclass import MemoryTypeSchema
from 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 TemplateUtils
def 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.py
index 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 AsyncioInstrumentor
AsyncioInstrumentor().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.py
index 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.py
index 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.py
index 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 = False
mock_config.return_value.memory = mock_memory_config
ctx = 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 = True
mock_config.return_value.memory = mock_memory_config
ctx = 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 = False
mock_config.return_value.memory = mock_memory_config
ctx = 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 = True
mock_config.return_value.memory = mock_memory_config
ctx = 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 = None
ctx = 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.py
new file mode 100644
index 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.py
index 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(monkeypatch
OpenVikingConfigSingleton.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.0
assert config.storage.transaction.redo_recovery_enabled is True
OpenVikingConfigSingleton.reset_instance()
@@ -323,8 +338,11 @@ def test_require_config_missing_message_uses_openviking_ai_docs(tmp_path, monkey
def 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 loader
monkeypatch.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, mo
def test_openviking_config_singleton_missing_message_uses_openviking_ai_docs(tmp_path, monkeypatch):
+ import openviking_cli.utils.config.config_loader as loader
import openviking_cli.utils.config.open_viking_config as config_module
from openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingleton
monkeypatch.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(tmp
def test_openviking_config_singleton_initialize_missing_message_uses_openviking_ai_docs(
tmp_path, monkeypatch
):
+ import openviking_cli.utils.config.config_loader as loader
import openviking_cli.utils.config.open_viking_config as config_module
from openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingleton
monkeypatch.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.py
new file mode 100644
index 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.py
deleted file mode 100644
index 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_text
diff --git a/uv.lock b/uv.lock
index 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" },