Skip to content

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

adapt for openclaw: add memory output language pipeline (#137)

Mingjian Queac638bf173ad
diff --git a/openviking/prompts/templates/compression/memory_extraction.yaml b/openviking/prompts/templates/compression/memory_extraction.yaml
index 16f35ec65..849cb99c3 100644
--- a/openviking/prompts/templates/compression/memory_extraction.yaml
+++ b/openviking/prompts/templates/compression/memory_extraction.yaml
@@ -25,12 +25,19 @@ variables:
description: "User feedback"
required: false
default: ""
+ - name: "output_language"
+ type: "string"
+ description: "Target language for extracted memory fields (abstract, overview, content)"
+ required: false
+ default: "auto"
template: |
Analyze the following session context and extract memories worth long-term preservation.
User: {{ user }}
+ Target Output Language: {{ output_language }} ("auto" means detect from recent messages)
+
{% if summary %}
## Session History Summary
{{ summary }}
@@ -218,6 +225,7 @@ template: |
}
Notes:
+ - The values of "abstract", "overview", and "content" MUST be written in {{ output_language }} (if output_language is "auto", use the dominant language in recent_messages).
- Only extract truly valuable personalized information
- If nothing worth recording, return {"memories": []}
- Preferences should be aggregated by topic, similar preferences should be merged into one memory
diff --git a/openviking/prompts/templates/compression/memory_merge.yaml b/openviking/prompts/templates/compression/memory_merge.yaml
index c1a133c24..868a6faac 100644
--- a/openviking/prompts/templates/compression/memory_merge.yaml
+++ b/openviking/prompts/templates/compression/memory_merge.yaml
@@ -19,11 +19,17 @@ variables:
type: "string"
description: "Memory category (profile, preferences, etc.)"
required: true
+ - name: "output_language"
+ type: "string"
+ description: "Target language for merged output (keep consistent with user language)"
+ required: false
+ default: "auto"
template: |
Merge the following memory information into a single, coherent content.
**Category**: {{ category }}
+ **Target Output Language**: {{ output_language }} ("auto" means infer from existing/new memory language)
**Existing Content:**
{{ existing_content }}
@@ -36,6 +42,8 @@ template: |
- Keep the most up-to-date details
- Maintain a coherent narrative
- Output ONLY the merged content, no explanation
+ - Output MUST be written in **{{ output_language }}** (if output_language is "auto", infer dominant language from inputs)
+ - Keep code identifiers / URIs / model names unchanged when they are proper nouns
llm_config:
temperature: 0.0
diff --git a/openviking/session/compressor.py b/openviking/session/compressor.py
index 59bc34dc6..a4b498b95 100644
--- a/openviking/session/compressor.py
+++ b/openviking/session/compressor.py
@@ -118,7 +118,10 @@ class SessionCompressor:
try:
existing_content = await viking_fs.read_file(target_memory.uri)
merged = await self.extractor._merge_memory(
- existing_content, candidate.content, candidate.category.value
+ existing_content,
+ candidate.content,
+ candidate.category.value,
+ output_language=candidate.language,
)
if merged:
await viking_fs.write_file(target_memory.uri, merged)
diff --git a/openviking/session/memory_extractor.py b/openviking/session/memory_extractor.py
index 3f7907086..42bfd693a 100644
--- a/openviking/session/memory_extractor.py
+++ b/openviking/session/memory_extractor.py
@@ -8,6 +8,7 @@ Extracts 6 categories of memories from session:
- AgentMemory: cases, patterns
"""
+import re
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional
@@ -47,6 +48,7 @@ class CandidateMemory:
content: str # L2: Full narrative, free Markdown
source_session: str
user: str
+ language: str = "auto"
class MemoryExtractor:
@@ -65,6 +67,49 @@ class MemoryExtractor:
def __init__(self):
"""Initialize memory extractor."""
+ @staticmethod
+ def _detect_output_language(messages: List, fallback_language: str = "en") -> str:
+ """Detect dominant language from user messages only.
+
+ We intentionally scope detection to user role content so assistant/system
+ text does not bias the target output language for stored memories.
+ """
+ fallback = (fallback_language or "en").strip() or "en"
+
+ user_text = "\n".join(
+ str(getattr(m, "content", "") or "")
+ for m in messages
+ if getattr(m, "role", "") == "user" and getattr(m, "content", None)
+ )
+
+ if not user_text:
+ return fallback
+
+ # Detect scripts that are largely language-unique first.
+ counts = {
+ "ko": len(re.findall(r"[\uac00-\ud7af]", user_text)),
+ "ru": len(re.findall(r"[\u0400-\u04ff]", user_text)),
+ "ar": len(re.findall(r"[\u0600-\u06ff]", user_text)),
+ }
+
+ detected, score = max(counts.items(), key=lambda item: item[1])
+ if score > 0:
+ return detected
+
+ # CJK disambiguation:
+ # - Japanese often includes Han characters too, so Han-count alone can
+ # misclassify Japanese as Chinese.
+ # - If any Kana is present, prioritize Japanese.
+ kana_count = len(re.findall(r"[\u3040-\u30ff\u31f0-\u31ff\uff66-\uff9f]", user_text))
+ han_count = len(re.findall(r"[\u4e00-\u9fff]", user_text))
+
+ if kana_count > 0:
+ return "ja"
+ if han_count > 0:
+ return "zh-CN"
+
+ return fallback
+
async def extract(
self,
context: dict,
@@ -86,6 +131,12 @@ class MemoryExtractor:
if not formatted_messages:
return []
+ config = get_openviking_config()
+ fallback_language = (config.language_fallback or "en").strip() or "en"
+ output_language = self._detect_output_language(
+ messages, fallback_language=fallback_language
+ )
+
# Call LLM to extract memories
prompt = render_prompt(
"compression.memory_extraction",
@@ -94,6 +145,7 @@ class MemoryExtractor:
"recent_messages": formatted_messages,
"user": user._user_id,
"feedback": "",
+ "output_language": output_language,
},
)
@@ -119,10 +171,13 @@ class MemoryExtractor:
content=mem.get("content", ""),
source_session=session_id,
user=user,
+ language=output_language,
)
)
- logger.info(f"Extracted {len(candidates)} candidate memories")
+ logger.info(
+ f"Extracted {len(candidates)} candidate memories (language={output_language})"
+ )
return candidates
except Exception as e:
@@ -211,12 +266,23 @@ class MemoryExtractor:
await viking_fs.write_file(uri=uri, content=candidate.content)
logger.info(f"Created profile at {uri}")
else:
- merged = await self._merge_memory(existing, candidate.content, "profile")
+ merged = await self._merge_memory(
+ existing,
+ candidate.content,
+ "profile",
+ output_language=candidate.language,
+ )
content = merged if merged else candidate.content
await viking_fs.write_file(uri=uri, content=content)
logger.info(f"Merged profile info to {uri}")
- async def _merge_memory(self, existing: str, new: str, category: str) -> Optional[str]:
+ async def _merge_memory(
+ self,
+ existing: str,
+ new: str,
+ category: str,
+ output_language: str = "auto",
+ ) -> Optional[str]:
"""Use LLM to merge existing and new memory content."""
vlm = get_openviking_config().vlm
if not vlm or not vlm.is_available():
@@ -224,7 +290,12 @@ class MemoryExtractor:
prompt = render_prompt(
"compression.memory_merge",
- {"existing_content": existing, "new_content": new, "category": category},
+ {
+ "existing_content": existing,
+ "new_content": new,
+ "category": category,
+ "output_language": output_language,
+ },
)
try:
diff --git a/openviking_cli/utils/config/open_viking_config.py b/openviking_cli/utils/config/open_viking_config.py
index 6e41e0cb2..cecfd8dc0 100644
--- a/openviking_cli/utils/config/open_viking_config.py
+++ b/openviking_cli/utils/config/open_viking_config.py
@@ -107,6 +107,14 @@ class OpenVikingConfig(BaseModel):
default=3600, description="Interval (seconds) to check for expired memories"
)
+ language_fallback: str = Field(
+ default="en",
+ description=(
+ "Fallback language used by memory extraction when dominant user language "
+ "cannot be confidently detected"
+ ),
+ )
+
log_level: str = Field(
default="WARNING", description="Logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL"
)
diff --git a/tests/session/test_memory_extractor_language.py b/tests/session/test_memory_extractor_language.py
new file mode 100644
index 000000000..e9113d4b2
--- /dev/null
+++ b/tests/session/test_memory_extractor_language.py
@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+
+try:
+ from openviking.session.memory_extractor import MemoryExtractor
+except Exception: # pragma: no cover - fallback for minimal local test env
+ logger_stub = SimpleNamespace(
+ info=lambda *a, **k: None, warning=lambda *a, **k: None, error=lambda *a, **k: None
+ )
+
+ modules = {
+ "openviking": ModuleType("openviking"),
+ "openviking.core": ModuleType("openviking.core"),
+ "openviking.core.context": ModuleType("openviking.core.context"),
+ "openviking.prompts": ModuleType("openviking.prompts"),
+ "openviking.session": ModuleType("openviking.session"),
+ "openviking.session.user_id": ModuleType("openviking.session.user_id"),
+ "openviking.storage": ModuleType("openviking.storage"),
+ "openviking.storage.viking_fs": ModuleType("openviking.storage.viking_fs"),
+ "openviking.utils": ModuleType("openviking.utils"),
+ "openviking.utils.config": ModuleType("openviking.utils.config"),
+ }
+
+ modules["openviking.core.context"].Context = object
+ modules["openviking.core.context"].ContextType = SimpleNamespace(
+ MEMORY=SimpleNamespace(value="memory")
+ )
+ modules["openviking.core.context"].Vectorize = object
+ modules["openviking.prompts"].render_prompt = lambda *a, **k: ""
+ modules["openviking.session.user_id"].UserIdentifier = object
+ modules["openviking.storage.viking_fs"].get_viking_fs = lambda: None
+ modules["openviking.utils"].get_logger = lambda _name: logger_stub
+ modules["openviking.utils.config"].get_openviking_config = lambda: SimpleNamespace(
+ language_fallback="en", vlm=None
+ )
+
+ for name, module in modules.items():
+ sys.modules.setdefault(name, module)
+
+ module_path = (
+ Path(__file__).resolve().parents[2] / "openviking" / "session" / "memory_extractor.py"
+ )
+ spec = importlib.util.spec_from_file_location(
+ "openviking.session.memory_extractor", module_path
+ )
+ memory_extractor = importlib.util.module_from_spec(spec)
+ assert spec and spec.loader
+ spec.loader.exec_module(memory_extractor)
+ MemoryExtractor = memory_extractor.MemoryExtractor
+
+
+def _msg(role: str, content: str):
+ return SimpleNamespace(role=role, content=content)
+
+
+def test_detect_output_language_japanese_kana_and_kanji():
+ messages = [
+ _msg(
+ "user",
+ "\u4eca\u65e5\u306f\u65b0\u6a5f\u80fd\u306e\u8a2d\u8a08\u3092\u9032\u3081\u307e\u3059",
+ )
+ ]
+ language = MemoryExtractor._detect_output_language(messages, fallback_language="en")
+ assert language == "ja"
+
+
+def test_detect_output_language_chinese_han_only():
+ messages = [
+ _msg("user", "\u4eca\u5929\u7ee7\u7eed\u4f18\u5316\u8bb0\u5fc6\u62bd\u53d6\u6a21\u5757")
+ ]
+ language = MemoryExtractor._detect_output_language(messages, fallback_language="en")
+ assert language == "zh-CN"
+
+
+def test_detect_output_language_japanese_with_more_han_than_kana():
+ messages = [
+ _msg(
+ "user",
+ "\u65b0\u6a5f\u80fd\u8a2d\u8a08\u306e\u65b9\u91dd\u3092\u78ba\u8a8d\u3057\u307e\u3059",
+ )
+ ]
+ language = MemoryExtractor._detect_output_language(messages, fallback_language="en")
+ assert language == "ja"