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
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.yamlindex 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: falsedefault: ""+ - 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 memorydiff --git a/openviking/prompts/templates/compression/memory_merge.yaml b/openviking/prompts/templates/compression/memory_merge.yamlindex 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 nounsllm_config:temperature: 0.0diff --git a/openviking/session/compressor.py b/openviking/session/compressor.pyindex 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.pyindex 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 refrom dataclasses import dataclassfrom enum import Enumfrom typing import List, Optional@@ -47,6 +48,7 @@ class CandidateMemory:content: str # L2: Full narrative, free Markdownsource_session: struser: 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 memoriesprompt = 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 candidatesexcept 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.contentawait 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().vlmif 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.pyindex 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.pynew file mode 100644index 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"