@modusensus/dsh-mneme 0.1.4 → 0.1.6

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![dsh-plugin](https://img.shields.io/badge/dsh-plugin-awesome-orange)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-129%20passed-success)](https://github.com/modusensus/dsh-mneme)
+[![tests](https://img.shields.io/badge/tests-136%20passed-success)](https://github.com/modusensus/dsh-mneme)
 
 > 给 DeepSeek Harness 的跨会话记忆插件：让 Agent 记住你、记住项目、自动整理记忆。**Mneme**（Μνήμη）——希腊记忆女神 Mnemosyne 之名，掌管记忆与梦境，正如 autoDream 在后台巩固记忆。
 
@@ -22,7 +22,7 @@
 | 工具 | 功能 |
 |------|------|
 | `memory_save` | 记录一条记忆（自动按标题去重合并） |
-| `memory_search` | 全文搜索（中文子串友好） |
+| `memory_search` | 全文搜索（中文子串友好，可启用向量语义搜索） |
 | `memory_list` | 按类型分页列出 |
 | `memory_update` | 修改已有记忆 |
 | `memory_delete` | 删除记忆 |
@@ -45,11 +45,11 @@
 
 ### Web 记忆面板
 
-侧边栏"记忆"按钮 → 模态面板：按类型浏览、全文搜索、查看详情。
+官方设置面板 → 「记忆库设置」→「记忆」标签：按类型浏览、全文搜索；启用向量搜索后可用「语义」切换做向量召回。
 
 ### 用户设置（画像 / 规则）与自定义指令 ⚙️
 
-侧边栏"设置"按钮 → 设置面板：
+官方设置面板 → 「记忆库设置」标签：
 
 - **用户画像**：一段自由文本描述用户自己（角色、背景、偏好），**每轮注入**到系统提示，让 Agent 始终遵循
 - **规则**：Agent 必须遵守的行为规则列表（如"回答先给结论"），同样每轮注入
@@ -57,6 +57,24 @@
 
 > 画像与规则通过独立的 `[用户设置]` 注入区块（优先级高于记忆库），即使记忆为空也会注入。
 
+### 向量搜索（语义搜索）🔎
+
+可选能力：接入 OpenAI 兼容的 embeddings API，让搜索能命中**字面不同但语义相近**的记忆。
+
+**配置**：官方设置 → 「记忆库设置」→ 滚动到底部「向量搜索」区块：
+
+| 字段 | 说明 |
+|------|------|
+| `启用向量搜索` | 总开关；开启后记忆面板出现「语义」切换 |
+| `API 地址 (Base URL)` | OpenAI 兼容端点，如 `https://api.openai.com/v1`；也支持 SiliconFlow、智谱、本地 Ollama 等 |
+| `API Key` | 对应服务的密钥 |
+| `模型名` | embedding 模型，如 `text-embedding-3-small`、`text-embedding-v3`、`bge-m3` 等 |
+
+保存配置后点「重建索引」，为已有记忆批量补建向量（新写入的记忆会自动嵌入）。之后在记忆面板输入查询并点「语义」，即可用向量召回语义相关结果；向量服务不可用时自动回退全文搜索。
+
+> ⚠️ 密钥仅保存在本机 `~/.dsh/memory/memory.db` 的 `user_settings` 表，不会上传，也不会写入代码仓库。
+> 需要 embedding 而非 rerank 模型：如阿里云 `text-embedding-v3` 可用，`qwen3-vl-rerank` 是 rerank 模型（不走 `/embeddings`）。
+
 ## 📦 安装
 
 ### 前置条件
@@ -138,7 +156,7 @@ dsh web
 │  autoDream：阈值调度 → LLM 决策清单               │
 │            → 校验（fail-safe）→ 应用 → 摘要       │
 ├─────────────────────────────────────────────────┤
-│  Web 面板：侧边栏入口 + 浏览/搜索/详情            │
+│  Web 面板：设置面板内嵌 + 浏览/搜索（含向量）    │
 └─────────────────────────────────────────────────┘
 ```
 
@@ -155,12 +173,13 @@ src/
 ├── summarize.js      # 会话结束 LLM 摘要
 ├── dream.js          # autoDream 调度 + runDream（LLM 决策 + 摘要）
 ├── dream/decisions.js# 决策校验（fail-safe）+ 决策应用
+├── embedding.js      # OpenAI 兼容 embeddings 客户端 + 向量检索
 ├── api.js            # HTTP 路由（Web 面板数据通道）
 └── index.js          # 插件接线
 lib/
 ├── client.js         # Web 面板（手写 ModuleLoader bundle）
 └── *.js              # src 的同步分发产物
-test/                 # 129 个 node:test 测试
+test/                 # 136 个 node:test 测试
 ```
 
 ## 🧪 开发
@@ -168,7 +187,7 @@ test/                 # 129 个 node:test 测试
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 129 个测试（--test-isolation=none 用于受限沙箱，禁止子进程 spawn）
+npm test           # 运行 136 个测试（--test-isolation=none 用于受限沙箱，禁止子进程 spawn）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```
 

package/lib/api.js

@@ -23,7 +23,7 @@ function parseBody(text) {
   }
 }
 
-export function createApi(ctx, service, settings, commands) {
+export function createApi(ctx, service, settings, commands, embedder) {
   const disposers = [];
 
   const register = (route) => {
@@ -64,8 +64,49 @@ export function createApi(ctx, service, settings, commands) {
         const url = new URL(req.url, "http://localhost");
         const q = url.searchParams.get("q") ?? "";
         const limit = Number(url.searchParams.get("limit") ?? 20);
-        const items = service.toApiList(service.search(q, { limit }));
-        sendJson(res, 200, { items });
+        // mode: auto (default) | keyword | vector
+        const mode = url.searchParams.get("mode") ?? "auto";
+        const query = q.trim();
+        if (!query) {
+          sendJson(res, 200, { items: [], mode: "keyword" });
+          return;
+        }
+        // Keyword results (existing behavior) always computed; used as a
+        // fallback and as the primary ranking when vector is unavailable.
+        const keyword = service.toApiList(service.search(query, { limit }));
+        if (mode === "keyword" || !embedder) {
+          sendJson(res, 200, { items: keyword, mode: "keyword" });
+          return;
+        }
+        const cfg = settings.getVectorConfig();
+        if (mode === "vector" && !cfg?.enabled) {
+          sendJson(res, 200, { items: keyword, mode: "keyword", error: "vector-disabled" });
+          return;
+        }
+        // Try vector search; on any failure fall back to keyword results.
+        return embedder.embed(query).then(async (vector) => {
+          let items = keyword;
+          let used = "keyword";
+          if (vector) {
+            const scored = service.toApiList(service.searchVector(vector, { limit }));
+            // Merge: keyword exact hits first (they are the user's literal
+            // words), then vector results fill the remaining slots, deduped.
+            const seen = new Set(keyword.map((m) => m.id));
+            const merged = [...keyword];
+            for (const m of scored) {
+              if (merged.length >= limit) break;
+              if (!seen.has(m.id)) {
+                seen.add(m.id);
+                merged.push(m);
+              }
+            }
+            items = merged;
+            used = "vector";
+          }
+          sendJson(res, 200, { items, mode: used });
+        }).catch(() => {
+          sendJson(res, 200, { items: keyword, mode: "keyword" });
+        });
       } catch {
         sendJson(res, 500, { error: "internal" });
       }
@@ -112,6 +153,54 @@ export function createApi(ctx, service, settings, commands) {
     }
   });
 
+  // --- vector search config ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/vector-config",
+    handler(req, res) {
+      try {
+        if (req.method === "PUT" || req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            const cfg = settings.setVectorConfig({
+              enabled: body.enabled,
+              baseUrl: body.baseUrl,
+              apiKey: body.apiKey,
+              model: body.model
+            });
+            sendJson(res, 200, { config: cfg });
+          });
+        }
+        sendJson(res, 200, { config: settings.getVectorConfig() ?? { enabled: false, baseUrl: "", apiKey: "", model: "" } });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- vector re-index (backfill embeddings for rows missing them) ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/vector-reindex",
+    handler(req, res) {
+      try {
+        if (!embedder) {
+          sendJson(res, 200, { indexed: 0, skipped: 0, error: "vector-unavailable" });
+          return;
+        }
+        const url = new URL(req.url, "http://localhost");
+        const limit = Number(url.searchParams.get("limit") ?? 100);
+        embedder.reindexMissing(limit).then((result) => {
+          sendJson(res, 200, result);
+        }).catch(() => {
+          sendJson(res, 200, { indexed: 0, skipped: 0, error: "vector-failed" });
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- custom commands ---
   register({
     kind: "exact",

package/lib/client.js

@@ -41,7 +41,19 @@ window.__ModuleLoader__.load({
         "memory.settings.cmdInstruction": "指令内容",
         "memory.settings.cmdAdd": "添加命令",
         "memory.settings.cmdDelete": "删除",
-        "memory.settings.empty": "暂无内容"
+        "memory.settings.empty": "暂无内容",
+        "memory.panel.semantic": "语义",
+        "memory.settings.vectorTitle": "向量搜索",
+        "memory.settings.vectorHint": "接入 OpenAI 兼容的 embeddings API 做语义搜索，可匹配字面不同但语义相近的记忆",
+        "memory.settings.vectorEnabled": "启用向量搜索",
+        "memory.settings.vectorBaseUrl": "API 地址 (Base URL)",
+        "memory.settings.vectorApiKey": "API Key",
+        "memory.settings.vectorModel": "模型名",
+        "memory.settings.vectorSave": "保存配置",
+        "memory.settings.vectorSaved": "配置已保存",
+        "memory.settings.vectorReindex": "重建索引",
+        "memory.settings.vectorReindexing": "索引中…",
+        "memory.settings.vectorReindexDone": "已索引 {n} 条"
       },
       en: {
         "memory.panel.title": "Memory",
@@ -70,7 +82,19 @@ window.__ModuleLoader__.load({
         "memory.settings.cmdInstruction": "Instruction",
         "memory.settings.cmdAdd": "Add Command",
         "memory.settings.cmdDelete": "Delete",
-        "memory.settings.empty": "Nothing yet"
+        "memory.settings.empty": "Nothing yet",
+        "memory.panel.semantic": "Semantic",
+        "memory.settings.vectorTitle": "Vector Search",
+        "memory.settings.vectorHint": "Connect an OpenAI-compatible embeddings API for semantic search by meaning, not just keywords",
+        "memory.settings.vectorEnabled": "Enable vector search",
+        "memory.settings.vectorBaseUrl": "Base URL",
+        "memory.settings.vectorApiKey": "API Key",
+        "memory.settings.vectorModel": "Model",
+        "memory.settings.vectorSave": "Save Config",
+        "memory.settings.vectorSaved": "Config saved",
+        "memory.settings.vectorReindex": "Reindex",
+        "memory.settings.vectorReindexing": "Indexing…",
+        "memory.settings.vectorReindexDone": "Indexed {n} items"
       }
     };
 
@@ -86,13 +110,22 @@ window.__ModuleLoader__.load({
       return Number.isNaN(date.getTime()) ? "—" : date.toLocaleString();
     }
 
-    function MemoryPanel({ t, onClose }) {
+    function MemoryPanel({ t, onClose, embedded }) {
       const [tab, setTab] = useState("all");
       const [query, setQuery] = useState("");
+      const [semantic, setSemantic] = useState(false);
+      const [vecEnabled, setVecEnabled] = useState(false);
       const [items, setItems] = useState([]);
       const [loading, setLoading] = useState(false);
       const abortRef = useRef(null);
 
+      useEffect(() => {
+        fetch("/api/dsh-mneme/vector-config")
+          .then((res) => res.json())
+          .then((d) => setVecEnabled(!!d.config?.enabled))
+          .catch(() => {});
+      }, []);
+
       const load = useCallback(async () => {
         abortRef.current?.abort();
         const controller = new AbortController();
@@ -102,7 +135,7 @@ window.__ModuleLoader__.load({
           const params = new URLSearchParams();
           if (tab !== "all") params.set("type", tab);
           const url = query.trim()
-            ? `/api/dsh-mneme/search?q=${encodeURIComponent(query.trim())}`
+            ? `/api/dsh-mneme/search?q=${encodeURIComponent(query.trim())}&mode=${semantic ? "vector" : "auto"}`
             : `/api/dsh-mneme/list?${params.toString()}`;
           const res = await fetch(url, { signal: controller.signal });
           const data = await res.json();
@@ -113,7 +146,7 @@ window.__ModuleLoader__.load({
         } finally {
           setLoading(false);
         }
-      }, [tab, query]);
+      }, [tab, query, semantic]);
 
       useEffect(() => {
         load();
@@ -122,19 +155,24 @@ window.__ModuleLoader__.load({
 
       const tabs = ["all", "preference", "project", "decision", "history"];
 
-      return createPortal(
-        react.createElement("div", { style: styles.overlay },
-          react.createElement("div", { style: styles.panel },
-            react.createElement("div", { style: styles.header },
-              react.createElement("span", { style: styles.title }, t("memory.panel.title")),
-              react.createElement("button", { style: styles.close, onClick: onClose }, "×")
+      const body = react.createElement("div", { style: embedded ? { ...styles.panel, width: "100%", maxWidth: "100%", maxHeight: "none" } : styles.panel },
+        !embedded && react.createElement("div", { style: styles.header },
+          react.createElement("span", { style: styles.title }, t("memory.panel.title")),
+          react.createElement("button", { style: styles.close, onClick: onClose }, "×")
+        ),
+            react.createElement("div", { style: { display: "flex", gap: 6, alignItems: "center", marginBottom: 12 } },
+              react.createElement("input", {
+                style: { ...styles.search, flex: 1, marginBottom: 0 },
+                placeholder: t("memory.panel.search"),
+                value: query,
+                onChange: (e) => setQuery(e.target.value)
+              }),
+              vecEnabled && react.createElement("button", {
+                style: { ...styles.tab, ...(semantic ? styles.tabActive : {}) },
+                title: t("memory.settings.vectorTitle"),
+                onClick: () => setSemantic(!semantic)
+              }, t("memory.panel.semantic"))
             ),
-            react.createElement("input", {
-              style: styles.search,
-              placeholder: t("memory.panel.search"),
-              value: query,
-              onChange: (e) => setQuery(e.target.value)
-            }),
             react.createElement("div", { style: styles.tabs },
               tabs.map((key) =>
                 react.createElement("button", {
@@ -164,16 +202,17 @@ window.__ModuleLoader__.load({
                       )
                     )
             )
-          )
-        ),
-        document.body
       );
+      return embedded
+        ? body
+        : createPortal(react.createElement("div", { style: styles.overlay }, body), document.body);
     }
 
     const h = react.createElement;
 
     // --- Settings panel: user profile, rules, custom commands ---
-    function SettingsPanel({ t, onClose }) {
+    function SettingsPanel({ t, onClose, embedded }) {
+      const [sectionTab, setSectionTab] = react.useState("settings");
       const [profile, setProfile] = react.useState("");
       const [rules, setRules] = react.useState([]);
       const [commands, setCommands] = react.useState([]);
@@ -181,17 +220,23 @@ window.__ModuleLoader__.load({
       const [newCmd, setNewCmd] = react.useState({ name: "", description: "", instruction: "" });
       const [saved, setSaved] = react.useState(false);
       const [cmdError, setCmdError] = react.useState("");
+      const [vector, setVector] = react.useState({ enabled: false, baseUrl: "", apiKey: "", model: "" });
+      const [vectorSaved, setVectorSaved] = react.useState(false);
+      const [reindexing, setReindexing] = react.useState(false);
+      const [reindexMsg, setReindexMsg] = react.useState("");
 
       const load = react.useCallback(async () => {
         try {
-          const [p, r, c] = await Promise.all([
+          const [p, r, c, v] = await Promise.all([
             fetch("/api/dsh-mneme/profile").then((res) => res.json()),
             fetch("/api/dsh-mneme/rules").then((res) => res.json()),
-            fetch("/api/dsh-mneme/commands").then((res) => res.json())
+            fetch("/api/dsh-mneme/commands").then((res) => res.json()),
+            fetch("/api/dsh-mneme/vector-config").then((res) => res.json())
           ]);
           setProfile(p.profile || "");
           setRules(Array.isArray(r.rules) ? r.rules : []);
           setCommands(Array.isArray(c.commands) ? c.commands : []);
+          setVector(v.config || { enabled: false, baseUrl: "", apiKey: "", model: "" });
         } catch { /* ignore */ }
       }, []);
 
@@ -255,24 +300,52 @@ window.__ModuleLoader__.load({
         setCommands(commands.filter((c) => c.id !== id));
       }
 
+      async function saveVector() {
+        try {
+          await fetch("/api/dsh-mneme/vector-config", {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(vector)
+          });
+          setVectorSaved(true);
+          setTimeout(() => setVectorSaved(false), 1500);
+        } catch { /* ignore */ }
+      }
+
+      async function reindex() {
+        setReindexing(true);
+        setReindexMsg("");
+        try {
+          const res = await fetch("/api/dsh-mneme/vector-reindex");
+          const data = await res.json();
+          const n = data.indexed ?? 0;
+          setReindexMsg(t("memory.settings.vectorReindexDone").replace("{n}", String(n)));
+        } catch { setReindexMsg(""); }
+        setReindexing(false);
+      }
+
       const inputStyle = { ...styles.search, marginBottom: 8 };
       const labelStyle = { fontSize: 12, fontWeight: 600, margin: "12px 0 4px" };
       const hintStyle = { fontSize: 11, color: "var(--dsw-alias-label-tertiary, #999)", marginBottom: 8 };
       const rowStyle = { display: "flex", justifyContent: "space-between", alignItems: "center", gap: 8, padding: "6px 0", borderBottom: "1px solid var(--dsw-alias-border-l1, #eee)" };
 
-      return createPortal(
-        h("div", { style: styles.overlay },
-          h("div", { style: styles.panel },
-            h("div", { style: styles.header },
-              h("span", { style: styles.title }, t("memory.settings.title")),
-              h("button", { style: styles.close, onClick: onClose }, "×")
-            ),
-            h("div", { style: { overflowY: "auto" } },
+      const body = h("div", { style: embedded ? { ...styles.panel, width: "100%", maxWidth: "100%", maxHeight: "none" } : styles.panel },
+        !embedded && h("div", { style: styles.header },
+          h("span", { style: styles.title }, t("memory.settings.title")),
+          h("button", { style: styles.close, onClick: onClose }, "×")
+        ),
+        h("div", { style: styles.tabs },
+          h("button", { style: { ...styles.tab, ...(sectionTab === "memory" ? styles.tabActive : {}) }, onClick: () => setSectionTab("memory") }, t("memory.panel.open")),
+          h("button", { style: { ...styles.tab, ...(sectionTab === "settings" ? styles.tabActive : {}) }, onClick: () => setSectionTab("settings") }, t("memory.settings.title"))
+        ),
+        sectionTab === "memory"
+          ? h(MemoryPanel, { t, embedded: true })
+          : h("div", { style: { overflowY: "auto" } },
               // profile
               h("div", { style: labelStyle }, t("memory.settings.profile")),
               h("div", { style: hintStyle }, t("memory.settings.profileHint")),
               h("textarea", {
-                style: { ...inputStyle, minHeight: 72, resize: "vertical", fontFamily: "inherit" },
+                style: { ...inputStyle, minHeight: 72, resize: "both", fontFamily: "inherit" },
                 value: profile,
                 placeholder: t("memory.settings.profile"),
                 onChange: (e) => setProfile(e.target.value)
@@ -316,15 +389,31 @@ window.__ModuleLoader__.load({
               h("div", { style: { display: "grid", gap: 6, marginTop: 6 } },
                 h("input", { style: { ...inputStyle, marginBottom: 0 }, value: newCmd.name, placeholder: t("memory.settings.cmdName"), onChange: (e) => setNewCmd({ ...newCmd, name: e.target.value }) }),
                 h("input", { style: { ...inputStyle, marginBottom: 0 }, value: newCmd.description, placeholder: t("memory.settings.cmdDesc"), onChange: (e) => setNewCmd({ ...newCmd, description: e.target.value }) }),
-                h("textarea", { style: { ...inputStyle, marginBottom: 0, minHeight: 48, resize: "vertical", fontFamily: "inherit" }, value: newCmd.instruction, placeholder: t("memory.settings.cmdInstruction"), onChange: (e) => setNewCmd({ ...newCmd, instruction: e.target.value }) }),
+                h("textarea", { style: { ...inputStyle, marginBottom: 0, minHeight: 48, resize: "both", fontFamily: "inherit" }, value: newCmd.instruction, placeholder: t("memory.settings.cmdInstruction"), onChange: (e) => setNewCmd({ ...newCmd, instruction: e.target.value }) }),
                 h("button", { style: styles.footerButton, onClick: addCommand }, t("memory.settings.cmdAdd")),
                 cmdError && h("div", { style: { fontSize: 12, color: "var(--dsw-alias-state-error, #c33)" } }, cmdError)
+              ),
+              // vector search
+              h("div", { style: { ...labelStyle, marginTop: 20 } }, t("memory.settings.vectorTitle")),
+              h("div", { style: hintStyle }, t("memory.settings.vectorHint")),
+              h("label", { style: { display: "flex", alignItems: "center", gap: 6, marginBottom: 8, fontSize: 13 } },
+                h("input", { type: "checkbox", checked: !!vector.enabled, onChange: (e) => setVector({ ...vector, enabled: e.target.checked }) }),
+                h("span", null, t("memory.settings.vectorEnabled"))
+              ),
+              h("input", { style: inputStyle, value: vector.baseUrl, placeholder: t("memory.settings.vectorBaseUrl"), onChange: (e) => setVector({ ...vector, baseUrl: e.target.value }) }),
+              h("input", { style: inputStyle, type: "password", value: vector.apiKey, placeholder: t("memory.settings.vectorApiKey"), onChange: (e) => setVector({ ...vector, apiKey: e.target.value }) }),
+              h("input", { style: inputStyle, value: vector.model, placeholder: t("memory.settings.vectorModel"), onChange: (e) => setVector({ ...vector, model: e.target.value }) }),
+              h("div", { style: { display: "flex", alignItems: "center", gap: 6, flexWrap: "wrap" } },
+                h("button", { style: styles.footerButton, onClick: saveVector }, t("memory.settings.vectorSave")),
+                vectorSaved && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-success, #2a7)" } }, t("memory.settings.vectorSaved")),
+                h("button", { style: styles.footerButton, onClick: reindex, disabled: reindexing }, reindexing ? t("memory.settings.vectorReindexing") : t("memory.settings.vectorReindex")),
+                reindexMsg && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary, #666)" } }, reindexMsg)
               )
             )
-          )
-        ),
-        document.body
       );
+      return embedded
+        ? body
+        : createPortal(h("div", { style: styles.overlay }, body), document.body);
     }
 
     const styles = {
@@ -351,32 +440,18 @@ window.__ModuleLoader__.load({
     function apply(ctx) {
       ctx.effect(() => ctx.locale.register(NS, dictionaries), "dsh-mneme: dictionaries");
 
+      // Register a custom section inside the DSH settings panel (nav label +
+      // embedded memory/settings content). Access is via the official settings
+      // panel only; no sidebar buttons are registered.
       ctx.effect(() => {
         const t = ctx.locale.bind(NS);
-        return ctx.slots.inject("sidebar.footer.action", () =>
-          ctx.slots.register({
-            name: "sidebar.footer.action",
-            id: "memory",
-            locale: NS,
-            inject: () => ({})
-          }, () => {
-            const [open, setOpen] = react.useState(false);
-            const [openSettings, setOpenSettings] = react.useState(false);
-            return react.createElement(react.Fragment, null,
-              react.createElement("button", {
-                onClick: () => setOpen(true),
-                style: { ...styles.footerButton, ...(open ? styles.footerButtonActive : {}) }
-              }, t("memory.panel.open")),
-              react.createElement("button", {
-                onClick: () => setOpenSettings(true),
-                style: { ...styles.footerButton, ...(openSettings ? styles.footerButtonActive : {}) }
-              }, t("memory.settings.open")),
-              open && react.createElement(MemoryPanel, { t, onClose: () => setOpen(false) }),
-              openSettings && react.createElement(SettingsPanel, { t, onClose: () => setOpenSettings(false) })
-            );
-          })
-        );
-      }, "dsh-mneme: sidebar action");
+        return ctx.slots.register({
+          name: "settings.section",
+          id: "dsh-mneme",
+          label: () => t("memory.settings.title"),
+          inject: () => ({})
+        }, () => react.createElement(SettingsPanel, { t, embedded: true, onClose: () => {} }));
+      }, "dsh-mneme: settings section");
     }
 
     exports.apply = apply;

package/lib/embedding.js

@@ -0,0 +1,97 @@
+// OpenAI-compatible embedding client for vector search. DSH's LLM service is
+// chat-only, so dsh-mneme calls an external `/embeddings` endpoint itself.
+// Works with OpenAI, SiliconFlow, Zhipu, local Ollama (via OpenAI-compatible
+// proxy) and any provider exposing the standard embeddings API.
+const DEFAULT_TIMEOUT_MS = 15000;
+
+/** Normalize a configured baseUrl into the full embeddings endpoint URL. */
+function embeddingsUrl(baseUrl) {
+  const base = String(baseUrl ?? "").trim().replace(/\/+$/, "");
+  if (!base) return "";
+  // Accept both "https://host/v1" and a full path ending in /embeddings.
+  if (/\/embeddings$/i.test(base)) return base;
+  return `${base}/embeddings`;
+}
+
+/**
+ * Call the embeddings API for one text. Resolves to a Float64 array, or null
+ * when the provider is not configured, the call fails, or the response is
+ * unusable. Never throws: failures degrade to keyword search.
+ */
+export async function embedText({ baseUrl, apiKey, model }, text) {
+  const url = embeddingsUrl(baseUrl);
+  if (!url || !apiKey || !model || !text) return null;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ model, input: String(text).slice(0, 8000) }),
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return null;
+  }
+  const vec = body?.data?.[0]?.embedding;
+  return Array.isArray(vec) && vec.length ? Array.from(vec) : null;
+}
+
+/**
+ * Embedder bound to the current settings + store: on each write it re-embeds
+ * the row's title+content and stores the vector. Failures are swallowed so a
+ * flaky embedding endpoint never breaks memory writes.
+ */
+export function createEmbedder({ store, settings, logger }) {
+  async function embedFor(id, title, content) {
+    const cfg = settings.getVectorConfig();
+    if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return;
+    const text = [title, content].filter(Boolean).join("\n");
+    const vector = await embedText(cfg, text);
+    if (vector) {
+      store.setEmbedding(id, vector);
+      logger?.info?.(`[dsh-mneme] embedded memory ${id} (dim=${vector.length})`);
+    }
+  }
+
+  return {
+    /** Fire-and-forget re-embed of a memory after any write. */
+    schedule(memory) {
+      if (!memory?.id) return;
+      embedFor(memory.id, memory.title, memory.content).catch(() => {});
+    },
+
+    /** Embed one text and return its vector (null on failure/disabled). */
+    async embed(query) {
+      const cfg = settings.getVectorConfig();
+      if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return null;
+      return embedText(cfg, query);
+    },
+
+    /** Batch re-index rows still missing an embedding. */
+    async reindexMissing(limit = 50) {
+      const cfg = settings.getVectorConfig();
+      if (!cfg?.enabled) return { indexed: 0, skipped: 0 };
+      const rows = store.needsEmbedding(limit);
+      let indexed = 0;
+      for (const row of rows) {
+        const text = [row.title, row.content].filter(Boolean).join("\n");
+        const vector = await embedText(cfg, text);
+        if (vector) {
+          store.setEmbedding(row.id, vector);
+          indexed++;
+        }
+      }
+      return { indexed, skipped: rows.length - indexed };
+    }
+  };
+}

package/lib/index.js

@@ -8,6 +8,7 @@ import { createDreamScheduler } from "./dream.js";
 import { createApi } from "./api.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
+import { createEmbedder } from "./embedding.js";
 import { Config } from "./config.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -39,6 +40,11 @@ export const apply = (ctx, config) => {
   // same SQLite file but live in dedicated tables, isolated from memories.
   const settings = createSettings(store.db);
 
+  // Vector search: embedder calls the configured OpenAI-compatible embeddings
+  // endpoint on writes and for queries. service re-embeds after each write.
+  const embedder = createEmbedder({ store, settings, logger: ctx.logger });
+  service.setEmbedder(embedder);
+
   // Custom commands: register persisted commands into the DSH command registry
   // on boot; add/remove re-register live through the API.
   let commands = null;
@@ -85,7 +91,7 @@ export const apply = (ctx, config) => {
   });
 
   ctx.inject(["tools"], (toolsCtx) => {
-    disposers.push(createTools(toolsCtx, service, cfg));
+    disposers.push(createTools(toolsCtx, service, cfg, embedder));
   });
 
   const summarizer = createSummarizer(ctx, service, cfg);
@@ -96,7 +102,7 @@ export const apply = (ctx, config) => {
       add: () => { throw new Error("commands unavailable"); },
       remove: () => false,
       list: () => []
-    });
+    }, embedder);
     disposers.push(api.dispose);
   }