feat(memory): configure semantic embedding schema

coding-agent/helm/templates/configmap-agent-config.yaml

@@ -38,6 +38,9 @@ data:
       "session_metrics",
       "shell_session",
       "skills",
+      {{- if .Values.memory.semantic.enabled }}
+      "semantic_memory",
+      {{- end }}
       {{- if .Values.kb.enabled }}
       "kb",
       {{- end }}
@@ -54,6 +57,21 @@ data:
     local = {{ printf "%s/local.sqlite3" .Values.persistence.data.mountPath | quote }}
     docs = {{ printf "%s/docs" .Values.persistence.data.mountPath | quote }}
 
+    {{- if .Values.memory.semantic.enabled }}
+    [memory.semantic]
+    enabled = true
+    backend = {{ .Values.memory.semantic.backend | quote }}
+    db_path = {{ printf "%s/%s" (.Values.persistence.data.mountPath | trimSuffix "/") (.Values.memory.semantic.dbPath | trimPrefix "/") | quote }}
+    table_name = {{ .Values.memory.semantic.tableName | quote }}
+    embedding_provider_id = {{ .Values.memory.semantic.embeddingProviderId | quote }}
+    embedding_model = {{ .Values.memory.semantic.embeddingModel | quote }}
+    embedding_dim = {{ .Values.memory.semantic.embeddingDim }}
+    {{- if .Values.memory.semantic.embeddingBaseUrl }}
+    embedding_base_url = {{ .Values.memory.semantic.embeddingBaseUrl | quote }}
+    {{- end }}
+
+    {{- end }}
+
     {{- if .Values.kb.enabled }}
     [kb]
     db_path = {{ printf "%s/%s" (.Values.persistence.data.mountPath | trimSuffix "/") (.Values.kb.dbPath | trimPrefix "/") | quote }}

coding-agent/helm/values.yaml

@@ -109,6 +109,17 @@ agent:
       memoryLimitMb: null
       dockerImage: python:3.11-slim
 
+memory:
+  semantic:
+    enabled: false
+    backend: lancedb
+    dbPath: semantic-memory
+    tableName: semantic_memory
+    embeddingProviderId: openai
+    embeddingModel: text-embedding-3-small
+    embeddingDim: 1536
+    embeddingBaseUrl: null
+
 kb:
   enabled: false
   dbPath: kb

coding-agent/src/coding_agent/core/app.py

@@ -5,7 +5,7 @@
 import uuid
 from collections.abc import Mapping
 from contextlib import contextmanager
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
 
@@ -78,6 +78,8 @@ def to_config_dict(self) -> dict[str, object]:
             payload["table_name"] = self.table_name
         if self.embedding_base_url is not None:
             payload["embedding_base_url"] = self.embedding_base_url
+        if schema_payload := _semantic_schema_config_payload(self.backend, self.schema):
+            payload.update(schema_payload)
         return payload
 
 
@@ -231,20 +233,97 @@ def _parse_semantic_memory_config(
     embedding_base_url = raw_semantic_cfg.get("embedding_base_url")
     if embedding_base_url is not None and not isinstance(embedding_base_url, str):
         raise ValueError("[memory.semantic].embedding_base_url must be a string")
+    schema = _semantic_schema_from_config(backend, raw_semantic_cfg)
     return SemanticMemoryConfig(
         enabled=enabled,
         backend=backend,
-        schema=(
-            _default_semantic_schema(backend)
-            if backend in semantic_backend_registry.available_semantic_memory_backends()
-            else FAKE_SEMANTIC_INDEX_SCHEMA
-        ),
+        schema=schema,
         db_path=db_path,
         table_name=table_name,
         embedding_base_url=embedding_base_url,
     )
 
 
+def _semantic_schema_from_config(
+    backend: str,
+    raw_semantic_cfg: Mapping[str, Any],
+) -> SemanticIndexSchema:
+    embedding_provider_id = _optional_semantic_string(
+        raw_semantic_cfg,
+        "embedding_provider_id",
+    )
+    embedding_model = _optional_semantic_string(
+        raw_semantic_cfg,
+        "embedding_model",
+    )
+    embedding_dim = _optional_semantic_positive_int(
+        raw_semantic_cfg,
+        "embedding_dim",
+    )
+    if backend not in semantic_backend_registry.available_semantic_memory_backends():
+        return FAKE_SEMANTIC_INDEX_SCHEMA
+    default_schema = _default_semantic_schema(backend)
+    return replace(
+        default_schema,
+        embedding_provider_id=(
+            embedding_provider_id
+            if embedding_provider_id is not None
+            else default_schema.embedding_provider_id
+        ),
+        embedding_model=(
+            embedding_model
+            if embedding_model is not None
+            else default_schema.embedding_model
+        ),
+        embedding_dim=(
+            embedding_dim if embedding_dim is not None else default_schema.embedding_dim
+        ),
+    )
+
+
+def _semantic_schema_config_payload(
+    backend: str,
+    schema: SemanticIndexSchema,
+) -> dict[str, object]:
+    if backend not in semantic_backend_registry.available_semantic_memory_backends():
+        return {}
+    default_schema = _default_semantic_schema(backend)
+    payload: dict[str, object] = {}
+    if schema.embedding_provider_id != default_schema.embedding_provider_id:
+        payload["embedding_provider_id"] = schema.embedding_provider_id
+    if schema.embedding_model != default_schema.embedding_model:
+        payload["embedding_model"] = schema.embedding_model
+    if schema.embedding_dim != default_schema.embedding_dim:
+        payload["embedding_dim"] = schema.embedding_dim
+    return payload
+
+
+def _optional_semantic_string(
+    raw_semantic_cfg: Mapping[str, Any],
+    key: str,
+) -> str | None:
+    value = raw_semantic_cfg.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ValueError(f"[memory.semantic].{key} must be a string")
+    if not value.strip():
+        raise ValueError(f"[memory.semantic].{key} must be non-empty")
+    return value
+
+
+def _optional_semantic_positive_int(
+    raw_semantic_cfg: Mapping[str, Any],
+    key: str,
+) -> int | None:
+    value = raw_semantic_cfg.get(key)
+    if value is None:
+        return None
+    if type(value) is not int or value <= 0:
+        raise ValueError(f"[memory.semantic].{key} must be a positive integer")
+    return value
+
+
 def _default_semantic_schema(backend: str) -> SemanticIndexSchema:
     if backend == "fake":
         return FAKE_SEMANTIC_INDEX_SCHEMA

coding-agent/tests/coding_agent/test_memory_switch.py

@@ -797,9 +797,18 @@ def create_backend(
         db_path: object,
         table_name: object,
         embedding_base_url: object,
+        embedding_fn: object | None = None,
     ) -> FakeSemanticMemoryBackend:
         calls.append(
-            (backend, schema, data_dir, db_path, table_name, embedding_base_url)
+            (
+                backend,
+                schema,
+                data_dir,
+                db_path,
+                table_name,
+                embedding_base_url,
+                embedding_fn,
+            )
         )
         return RecordingBackend(schema=schema)
 
@@ -823,6 +832,7 @@ def create_backend(
             None,
             "semantic_memory",
             None,
+            None,
         )
     ]
     assert isinstance(ctx.config["semantic_memory_backend"], RecordingBackend)
@@ -870,6 +880,132 @@ def test_semantic_enabled_lancedb_backend_uses_configured_local_path(
     assert "semantic_memory" in pipeline._registry.plugin_ids()
 
 
+def test_semantic_enabled_lancedb_backend_uses_configured_embedding_schema(
+    tmp_path: Path,
+) -> None:
+    config_path = _default_plugin_config(
+        tmp_path,
+        memory="""
+
+[memory]
+read_enabled = true
+write_enabled = true
+
+[memory.semantic]
+enabled = true
+backend = "lancedb"
+db_path = "semantic-memory"
+embedding_provider_id = "siliconflow"
+embedding_model = "BAAI/bge-m3"
+embedding_dim = 1024
+embedding_base_url = "https://api.siliconflow.cn/v1"
+""",
+    )
+
+    _pipeline, ctx = create_agent(
+        config_path=config_path,
+        data_dir=tmp_path / "data",
+        api_key="sk-test",
+    )
+
+    backend = ctx.config["semantic_memory_backend"]
+    assert backend.schema.embedding_provider_id == "siliconflow"
+    assert backend.schema.embedding_model == "BAAI/bge-m3"
+    assert backend.schema.embedding_dim == 1024
+    assert ctx.config["memory"]["semantic"] == {
+        "enabled": True,
+        "backend": "lancedb",
+        "db_path": "semantic-memory",
+        "embedding_base_url": "https://api.siliconflow.cn/v1",
+        "embedding_provider_id": "siliconflow",
+        "embedding_model": "BAAI/bge-m3",
+        "embedding_dim": 1024,
+    }
+
+
+def test_semantic_config_dict_emits_only_changed_embedding_schema_overrides(
+    tmp_path: Path,
+) -> None:
+    config_path = _default_plugin_config(
+        tmp_path,
+        memory="""
+
+[memory]
+
+[memory.semantic]
+enabled = true
+backend = "lancedb"
+embedding_dim = 1024
+""",
+    )
+
+    _pipeline, ctx = create_agent(
+        config_path=config_path,
+        data_dir=tmp_path / "data",
+        api_key="sk-test",
+    )
+
+    assert ctx.config["memory"]["semantic"] == {
+        "enabled": True,
+        "backend": "lancedb",
+        "embedding_dim": 1024,
+    }
+
+
+def test_semantic_enabled_rejects_empty_embedding_schema_override(
+    tmp_path: Path,
+) -> None:
+    config_path = _default_plugin_config(
+        tmp_path,
+        memory="""
+
+[memory]
+
+[memory.semantic]
+enabled = true
+backend = "lancedb"
+embedding_model = ""
+""",
+    )
+
+    with pytest.raises(
+        ValueError,
+        match=r"\[memory\.semantic\]\.embedding_model must be non-empty",
+    ):
+        create_agent(
+            config_path=config_path,
+            data_dir=tmp_path / "data",
+            api_key="sk-test",
+        )
+
+
+def test_semantic_enabled_rejects_whitespace_embedding_schema_override(
+    tmp_path: Path,
+) -> None:
+    config_path = _default_plugin_config(
+        tmp_path,
+        memory="""
+
+[memory]
+
+[memory.semantic]
+enabled = true
+backend = "lancedb"
+embedding_model = "   "
+""",
+    )
+
+    with pytest.raises(
+        ValueError,
+        match=r"\[memory\.semantic\]\.embedding_model must be non-empty",
+    ):
+        create_agent(
+            config_path=config_path,
+            data_dir=tmp_path / "data",
+            api_key="sk-test",
+        )
+
+
 def test_semantic_enabled_forwards_explicit_topic_dependencies_to_plugin(
     tmp_path: Path,
 ) -> None: