@modusensus/dsh-mneme 0.1.4 → 0.1.5

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;
@@ -96,7 +102,7 @@ export const apply = (ctx, config) => {
       add: () => { throw new Error("commands unavailable"); },
       remove: () => false,
       list: () => []
-    });
+    }, embedder);
     disposers.push(api.dispose);
   }
 

package/lib/service.js

@@ -6,6 +6,17 @@ export function createService({ store, mirror, config, onWrite }) {
   // passed in the constructor). Fired on the same write events as onWrite.
   let dreamHook = null;
 
+  // Optional vector embedder, installed via setEmbedder after creation. After
+  // any content write it fire-and-forgets a re-embed of the row so vector
+  // search stays in sync; failures are swallowed inside the embedder.
+  let embedder = null;
+
+  function scheduleEmbed(memory) {
+    if (embedder && memory?.id) {
+      try { embedder.schedule(memory); } catch { /* ignore */ }
+    }
+  }
+
   /**
    * Fire-and-forget write notification; errors are swallowed to keep write
    * paths clean. The store mutation has already committed, so a throwing
@@ -38,6 +49,7 @@ export function createService({ store, mirror, config, onWrite }) {
       });
       syncMirror();
       notifyWrite();
+      scheduleEmbed(merged);
       return { action: "merged", memory: merged };
     }
     const created = store.save({
@@ -50,6 +62,7 @@ export function createService({ store, mirror, config, onWrite }) {
     });
     syncMirror();
     notifyWrite();
+    scheduleEmbed(created);
     return { action: "created", memory: created };
   }
 
@@ -126,8 +139,11 @@ export function createService({ store, mirror, config, onWrite }) {
     mergeHumanEdits,
     toApiList,
     setDreamHook(fn) { dreamHook = fn; },
+    setEmbedder(emb) { embedder = emb; },
     // passthroughs used by tools and api layers; mutations keep the mirror in sync
     search: (q, o) => store.search(q, o),
+    searchVector: (v, o) => store.searchVector(v, o),
+    embeddedCount: () => store.embeddedCount(),
     list: (o) => store.list(o),
     all: () => store.all(),
     count: (type) => store.count(type),
@@ -141,6 +157,7 @@ export function createService({ store, mirror, config, onWrite }) {
       const updated = store.update(id, p);
       syncMirror();
       notifyWrite();
+      scheduleEmbed(updated);
       return updated;
     },
     setForget: (id, f) => {

package/lib/settings.js

@@ -115,6 +115,28 @@ export function createSettings(db) {
     removeCommand(id) {
       const result = db.prepare("DELETE FROM custom_commands WHERE id = ?").run(id);
       return result.changes > 0;
+    },
+
+    /** Vector-search provider config (OpenAI-compatible embeddings endpoint). */
+    getVectorConfig() {
+      const raw = getSetting("vector");
+      if (!raw) return undefined;
+      try {
+        const cfg = JSON.parse(raw);
+        return typeof cfg === "object" && cfg !== null ? cfg : undefined;
+      } catch {
+        return undefined;
+      }
+    },
+    setVectorConfig({ enabled, baseUrl, apiKey, model }) {
+      const cfg = {
+        enabled: enabled === true || enabled === 1,
+        baseUrl: String(baseUrl ?? "").trim().replace(/\/+$/, ""),
+        apiKey: String(apiKey ?? "").trim(),
+        model: String(model ?? "").trim()
+      };
+      setSetting("vector", JSON.stringify(cfg));
+      return cfg;
     }
   };
 }