@bcmyguest/openmem 0.6.3 → 0.8.0

package/providers/hindsight/lib/model-backend.mjs

@@ -1,9 +1,18 @@
 /**
  * Hindsight model routing: how the LiteLLM proxy in front of Hindsight reaches an LLM
- * (lemond, Ollama or a custom OpenAI-compatible URL), plus the reflect-model question and
+ * (lemond, Ollama, a custom OpenAI-compatible URL or Meridian), plus the reflect-model question and
  * `lemonade pull`. The meta wizard knows none of this; it calls configureModelRouting.
  */
 import { applyRoute, litellmConfig, saveConf } from "./litellm-routes.mjs";
+import {
+  chooseMeridian,
+  containerApiBase,
+  existingMeridianKey,
+  MERIDIAN_DEFAULT_BASE,
+  MERIDIAN_REFLECT_DEFAULT,
+  normalizeMeridianBase,
+  writeMeridianKey,
+} from "./meridian.mjs";
 import { ollamaModelNames, openAiModelIds } from "./probe.mjs";
 import {
   backendDefault,
@@ -26,9 +35,9 @@ async function pickBackend(ctx, h) {
     return;
   }
   h.info("Pick a backend first; only that server is contacted.");
-  h.info("1) lemond   2) ollama   3) custom OpenAI-compatible URL");
-  const defNum = def === "lemond" ? "1" : def === "ollama" ? "2" : "3";
-  const choice = await h.ask(ctx, "Model backend (1-3)", defNum);
+  h.info("1) lemond   2) ollama   3) custom OpenAI-compatible URL   4) Claude subscription (Meridian)");
+  const defNum = { lemond: "1", ollama: "2", custom: "3", meridian: "4" }[def] || "1";
+  const choice = await h.ask(ctx, "Model backend (1-4)", defNum);
   switch (choice) {
     case "1":
       ctx.backend = "lemond";
@@ -39,8 +48,11 @@ async function pickBackend(ctx, h) {
     case "3":
       ctx.backend = "custom";
       break;
+    case "4":
+      ctx.backend = "meridian";
+      break;
     default:
-      h.die("choose 1, 2 or 3");
+      h.die("choose 1, 2, 3 or 4");
   }
 }
 
@@ -125,7 +137,12 @@ async function chooseOllama(ctx, h) {
     "MEMORY_MODEL",
     process.env.PM_DEFAULT_MODEL || ctx.ollamaDefaultModel,
   );
-  if (ctx.ollamaJson) {
+  // Compose Ollama publishes 127.0.0.1:11434, so a saved compose choice must win over the host probe.
+  if (storedOr(ctx, h, "ollama", "MEMORY_OLLAMA_IN_COMPOSE", "0") === "1") {
+    ctx.ollamaInCompose = true;
+    ctx.apiBase = OLLAMA_COMPOSE_API_BASE;
+    h.info("Keeping Ollama in Docker (compose profile ollama); LiteLLM calls http://ollama:11434.");
+  } else if (ctx.ollamaJson) {
     ctx.ollamaInCompose = false;
     ctx.apiBase = OLLAMA_HOST_API_BASE;
   } else {
@@ -150,17 +167,18 @@ async function chooseCustom(ctx, h) {
   const defaultBase = storedOr(ctx, h, "custom", "MEMORY_API_BASE", ctx.customDefaultBase);
   const defaultModel = storedOr(ctx, h, "custom", "MEMORY_MODEL", ctx.lemondDefaultModel);
   h.info("The litellm container calls this URL. Host services use host.docker.internal.");
-  h.info("Examples: lemond http://host.docker.internal:13305/v1 ; Meridian http://host.docker.internal:3456/v1");
+  h.info("Example: lemond http://host.docker.internal:13305/v1. For a Claude subscription through Meridian, pick backend 4.");
   ctx.apiBase = await h.ask(ctx, "OpenAI-compatible base URL", defaultBase);
   ctx.model = await h.ask(ctx, "Model id the server serves", defaultModel);
   await askReflectModel(ctx, h);
 }
 
 /**
- * Step "3. Model backend": choose lemond, Ollama or a custom URL, write the LiteLLM route
+ * Step "3. Model backend": choose lemond, Ollama, a custom URL or Meridian, write the LiteLLM route
  * override when the choice differs from the shipped routes, and record it in wizard.conf.
  * With the Clack UI done (ctx.skipBackendStep) the answers come from PM_BACKEND,
- * PM_DEFAULT_MODEL, MEMORY_API_BASE and PM_REFLECT_MODEL instead.
+ * PM_DEFAULT_MODEL, MEMORY_API_BASE and PM_REFLECT_MODEL instead (Meridian adds
+ * MERIDIAN_BASE and MERIDIAN_API_KEY).
  *
  * @param {Record<string, any>} ctx
  * @param {Helpers} h
@@ -179,8 +197,15 @@ export async function chooseModelBackend(ctx, h) {
     if (ctx.backend === "ollama" && !ctx.apiBase) {
       ctx.apiBase = ctx.ollamaInCompose ? OLLAMA_COMPOSE_API_BASE : OLLAMA_HOST_API_BASE;
     }
+    if (ctx.backend === "meridian") {
+      ctx.meridianBase = normalizeMeridianBase(process.env.MERIDIAN_BASE || MERIDIAN_DEFAULT_BASE);
+      ctx.apiBase ||= containerApiBase(ctx.meridianBase);
+      ctx.reflectModel ||= MERIDIAN_REFLECT_DEFAULT;
+      ctx.meridianKey = existingMeridianKey(ctx, h).key;
+    }
     h.ok(`backend ${ctx.backend}, model ${ctx.model} (setup UI)`);
     await applyRoute(ctx, h);
+    if (ctx.backend === "meridian") writeMeridianKey(ctx, h);
     saveConf(ctx, h);
     return;
   }
@@ -205,10 +230,14 @@ export async function chooseModelBackend(ctx, h) {
     case "custom":
       await chooseCustom(ctx, h);
       break;
+    case "meridian":
+      await chooseMeridian(ctx, h);
+      break;
     default:
       h.die(`unknown backend ${ctx.backend}`);
   }
   h.ok(`backend ${ctx.backend}, model ${ctx.model}`);
   await applyRoute(ctx, h);
+  if (ctx.backend === "meridian") writeMeridianKey(ctx, h);
   saveConf(ctx, h);
 }

package/providers/hindsight/lib/probe.mjs

@@ -31,3 +31,24 @@ export function normalizeOpenAiBase(base) {
   if (!b.endsWith("/v1")) b += "/v1";
   return b;
 }
+
+/**
+ * GET `url` and report the HTTP status (0 when nothing answered) and the parsed JSON body.
+ * @param {string} url
+ * @param {{ headers?: Record<string, string>, timeoutMs?: number }} [opts]
+ * @returns {Promise<{ status: number, json: any }>}
+ */
+export async function fetchStatus(url, { headers = {}, timeoutMs = TIMEOUT_MS } = {}) {
+  try {
+    const res = await fetch(url, { headers, signal: AbortSignal.timeout(timeoutMs) });
+    let json = null;
+    try {
+      json = await res.json();
+    } catch {
+      json = null;
+    }
+    return { status: res.status, json };
+  } catch {
+    return { status: 0, json: null };
+  }
+}

package/providers/hindsight/lib/stack-env.mjs

@@ -4,11 +4,14 @@
  * Runs as a plain Node script step (no wizard context), so it only reads process
  * environment and the paths it is given.
  */
-import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { ensureLitellmEnv } from "../../../wizard/lib/litellm-env.mjs";
 import { envValue } from "../../../wizard/lib/paths.mjs";
 
+// Moved to wizard/lib/litellm-env.mjs (mem0 shares it); re-exported for existing importers.
+export { ensureLitellmEnv };
+
 /**
  * @param {{ repo: string, home: string, env: NodeJS.ProcessEnv }} opts
  * @returns {{ entries: [string, string][], drop: string[], report: string[] }}
@@ -25,17 +28,7 @@ export function prepareStackEnv({ repo, home, env }) {
     throw new Error(`MEMORY_BACKEND must be lemond or ollama (got: ${backend})`);
   }
 
-  if (!fs.existsSync(litellmEnv)) {
-    const key = crypto.randomBytes(24).toString("hex");
-    const body =
-      "# LiteLLM proxy secrets. Read by the litellm compose service. Do not commit.\n" +
-      `LITELLM_MASTER_KEY=sk-${key}\n` +
-      "# lemond ignores the key; any non-empty value works.\n" +
-      "LEMOND_API_KEY=placeholder\n" +
-      "# Hosted models: add the provider key here, e.g. ANTHROPIC_API_KEY=..., and reference it as os.environ/ANTHROPIC_API_KEY.\n";
-    fs.writeFileSync(litellmEnv, body, { mode: 0o600 });
-    console.log(`created ${litellmEnv} (mode 600)`);
-  }
+  if (ensureLitellmEnv(litellmEnv)) console.log(`created ${litellmEnv} (mode 600)`);
 
   const litellmConfig = fs.existsSync(overrideConfig)
     ? overrideConfig

package/providers/hindsight/lib/state.mjs

@@ -9,7 +9,7 @@ export const OLLAMA_HOST_API_BASE = "http://host.docker.internal:11434";
 /** LiteLLM api_base when Ollama is the compose `ollama` service. */
 export const OLLAMA_COMPOSE_API_BASE = "http://ollama:11434";
 
-export const BACKENDS = ["lemond", "ollama", "custom"];
+export const BACKENDS = ["lemond", "ollama", "custom", "meridian"];
 
 /**
  * Fill the Hindsight fields of the wizard context. Idempotent: a field that is already
@@ -23,6 +23,8 @@ export function ensureState(ctx) {
     litellmEnv: path.join(hs, "litellm.env"),
     litellmOverride: path.join(hs, "litellm.yaml"),
     agentJson: path.join(ctx.home || "", ".hindsight/coding-agent.json"),
+    /** Meridian's own env file from docs/meridian-litellm.md (read for MERIDIAN_API_KEY/HOST/PORT). */
+    meridianEnvFile: path.join(ctx.home || "", ".config/meridian/meridian.env"),
     lemondBase: "http://127.0.0.1:13305",
     ollamaBase: "http://127.0.0.1:11434",
     lemondDefaultModel: LEMOND_DEFAULT_MODEL,
@@ -41,6 +43,9 @@ export function ensureState(ctx) {
     portApi: "",
     portCp: "",
     hindsightUrl: "",
+    /** Meridian URL as seen from the host, and the key for litellm.env (backend meridian). */
+    meridianBase: "",
+    meridianKey: "",
   };
   for (const [key, value] of Object.entries(defaults)) {
     if (ctx[key] === undefined) ctx[key] = value;

package/providers/hindsight/lib/summary.mjs

@@ -1,6 +1,7 @@
 /** Hindsight's contribution to the wizard's closing summary. */
 import fs from "node:fs";
 import { composeCommandText } from "../../../wizard/lib/compose.mjs";
+import { MERIDIAN_GUIDE, MERIDIAN_TERMS_URL } from "./meridian.mjs";
 import { ensureState } from "./state.mjs";
 
 /**
@@ -19,14 +20,20 @@ export function summary(ctx) {
     `  control plane      http://127.0.0.1:${ctx.portCp}`,
     `  model              ${ctx.backend}, ${ctx.model} via ${modelWhere}`,
   ];
+  if (ctx.backend === "meridian") {
+    running.push(`  reflect model      ${ctx.reflectModel || ctx.model}`);
+    running.push(
+      `  Meridian           ${ctx.meridianBase || "(host URL not recorded)"} on the host (not managed by setup; LiteLLM calls ${ctx.apiBase})`,
+    );
+  }
   if (ctx.ollamaInCompose) {
     running.push(`  Ollama            http://127.0.0.1:11434 (compose service; LiteLLM uses http://ollama:11434)`);
   }
   const configFiles = [`  ${ctx.envFile}`];
   if (fs.existsSync(ctx.litellmOverride)) {
     configFiles.push(`  ${ctx.litellmOverride} (model routes; replaces config/litellm.*.yaml)`);
-  } else if (ctx.backend === "custom") {
-    configFiles.push(`  ${ctx.litellmOverride} (missing: custom backend needs it)`);
+  } else if (ctx.backend === "custom" || ctx.backend === "meridian") {
+    configFiles.push(`  ${ctx.litellmOverride} (missing: ${ctx.backend} backend needs it)`);
   } else configFiles.push(`  config/litellm.${ctx.backend}.yaml (shipped routes)`);
   const litellmUp = composeCommandText(ctx, "up", "-d", "litellm");
   const notes = [
@@ -34,6 +41,13 @@ export function summary(ctx) {
     `Reflect needs a capable model (memory-reflect alias). On a weak or remote LLM, edit ${ctx.litellmOverride} and point memory-reflect at Meridian, an OpenAI-compatible host, or a stronger local model — then: ${litellmUp}`,
     `Change later: rerun ./setup. For a route-only edit, run: ${litellmUp}`,
   ];
+  if (ctx.backend === "meridian") {
+    configFiles.push(`  ${ctx.litellmEnv} (MERIDIAN_API_KEY)`);
+    notes.push(
+      `Meridian must keep running on this host with MERIDIAN_HOST=0.0.0.0 so the LiteLLM container reaches it; see ${MERIDIAN_GUIDE}.`,
+      `Claude subscription use through Meridian is governed by Anthropic's Consumer Terms: ${MERIDIAN_TERMS_URL}`,
+    );
+  }
   if (ctx.smokeFailed) {
     notes.unshift(
       `Smoke retain/recall did not finish — stack is up; fix the model/LLM queue via http://127.0.0.1:${ctx.portCp} then re-run setup or: curl the wizard-smoke retain against ${ctx.hindsightUrl}`,

package/providers/hindsight/lib/validate.mjs

@@ -69,6 +69,12 @@ export function validateHindsight(ctx, h) {
   const model = conf("MEMORY_MODEL");
   const shipped = backend === "ollama" ? ctx.ollamaDefaultModel : ctx.lemondDefaultModel;
   const reflect = conf("MEMORY_REFLECT_MODEL");
+  if (backend === "meridian") {
+    if (!fs.existsSync(ctx.litellmOverride)) errors.push("meridian backend without litellm.yaml override");
+    if (!h.envValue(ctx.litellmEnv, "MERIDIAN_API_KEY")) errors.push("litellm.env missing MERIDIAN_API_KEY");
+    checks.push("Meridian route and key");
+    return;
+  }
   if (backend !== "custom" && model !== shipped && !reflect && !fs.existsSync(ctx.litellmOverride)) {
     errors.push("custom model without litellm.yaml override");
   }

package/providers/hindsight/wizard.mjs

@@ -44,8 +44,8 @@ export async function afterProvider(ctx, h) {
 }
 
 /**
- * Step "3. Model backend": lemond, Ollama or a custom OpenAI-compatible URL behind the
- * LiteLLM proxy.
+ * Step "3. Model backend": lemond, Ollama, a custom OpenAI-compatible URL or a Claude
+ * subscription through Meridian, behind the LiteLLM proxy.
  * @param {Record<string, any>} ctx
  * @param {Helpers} h
  */
@@ -78,6 +78,7 @@ export async function hydrate(ctx, h) {
   ctx.model = confGet(ctx, h, "MEMORY_MODEL") || ctx.lemondDefaultModel;
   ctx.apiBase = confGet(ctx, h, "MEMORY_API_BASE") || "";
   ctx.reflectModel = confGet(ctx, h, "MEMORY_REFLECT_MODEL") || "";
+  ctx.meridianBase = confGet(ctx, h, "MEMORY_MERIDIAN_URL") || "";
   ctx.ollamaInCompose = confGet(ctx, h, "MEMORY_OLLAMA_IN_COMPOSE") === "1";
   applyComposeProfiles(ctx);
 }

package/providers/mem0/OPERATOR.md

@@ -16,6 +16,7 @@ server only (no `/v1/` prefix).
 | Embedder / LLM keys for mem0 itself | Indexer sink (`MEMORY_SINK=mem0`) and host-gateway rewrite |
 | Create an API key (dashboard or `POST /api-keys`) | Store `MEM0_API_KEY` in `~/.config/personal-memory/mem0.env` (mode **600**) |
 | Optional `AUTH_DISABLED=true` (dev only) | Smoke: `GET /docs`, retain, search, delete-by-id |
+| Apply the printed `llm` / `embedder` blocks to mem0 (optional) | Optional stack LiteLLM for mem0's LLM: routes, `litellm.env`, profile `litellm` on `127.0.0.1` |
 
 ## URLs
 
@@ -76,7 +77,7 @@ via the launcher `cli/mem0-mcp.mjs` (loads the key from the env file, then
 
 ```sh
 MEMORY_PROVIDER=mem0 npx openmem install-mcp --yes
-# checkout: MEMORY_PROVIDER=mem0 npx . install-mcp --yes
+# checkout: MEMORY_PROVIDER=mem0 node cli/openmem.mjs install-mcp --yes
 # or accept the coding-agent MCP confirm in setup
 ```
 
@@ -111,14 +112,32 @@ Restart Cursor Agent after install.
 ```sh
 npx openmem switch mem0 --yes
 # later: npx openmem switch hindsight --yes
-# checkout: npx . switch mem0 --yes
+# checkout: node cli/openmem.mjs switch mem0 --yes
 ```
 
 Updates `wizard.conf` (and `config.toml` `[memory].provider` when present), restarts the stack
 unless `--no-stack`, and runs `install-mcp --provider-only` unless `--no-mcp`. Does **not**
 migrate memories. Flags: [README — Switch memory provider](../../README.md#switch-memory-provider).
 
+## Models through the stack LiteLLM
+
+Optional (wizard step 3, or `MEM0_LITELLM=1` under `--yes`): mem0's LLM, and
+its embedder when the backend has one, go through the stack LiteLLM. Inputs
+under `--yes`: `MEM0_LITELLM_BACKEND` (`ollama`, `custom`, `anthropic`,
+`meridian`), `MEM0_LITELLM_MODEL`, `MEM0_LITELLM_API_BASE`,
+`MEM0_LITELLM_EMBED_MODEL` (`none` keeps mem0's embedder),
+`MEM0_LITELLM_PORT` (default 4000), `ANTHROPIC_API_KEY`. The wizard writes
+`~/.config/personal-memory/mem0-litellm.yaml`, keeps keys in
+`~/.config/hindsight/litellm.env` (mode 600), and prints the mem0 `llm` /
+`embedder` blocks (provider `openai`, `openai_base_url`
+`http://127.0.0.1:<port>/v1`, `api_key` = `LITELLM_MASTER_KEY`). You apply
+them; the wizard never edits the mem0 server config. Key sources and limits:
+[docs/mem0.md](../../docs/mem0.md#models-through-the-stack-litellm-optional).
+
 ## Compose
 
 `providers/mem0/compose.yaml` defines no mem0 service — only env +
 `extra_hosts` on the shared `indexer`. Profile `mem0` selects that fragment.
+It also overlays the base `litellm` service: under profile `litellm` it
+publishes `127.0.0.1:${MEM0_LITELLM_PORT:-4000}` (never `0.0.0.0`) and its
+entrypoint exits unless `LITELLM_MASTER_KEY` starts with `sk-`.

package/providers/mem0/compose.yaml

@@ -13,9 +13,14 @@
 # What the base compose.yaml gives you:
 #   - `indexer` and `indexer-state-init` have no profile and no provider dependency, so they start for every
 #     provider. This fragment points the indexer at the mem0 server.
-#   - `litellm` and `hindsight` carry the profile "hindsight" and do not start under this profile.
+#   - `hindsight` carries the profile "hindsight" and never starts here.
+#   - `litellm` also carries its own profile "litellm". It starts only when the wizard's "route mem0's LLM through the
+#     stack LiteLLM" option is on, which writes COMPOSE_PROFILES=mem0,litellm. This fragment then publishes it on
+#     127.0.0.1:${MEM0_LITELLM_PORT:-4000} (loopback only, never 0.0.0.0) for a mem0 server on the host, and the
+#     entrypoint below refuses to start without LITELLM_MASTER_KEY (sk-...) from LITELLM_ENV_FILE. See docs/mem0.md.
 # Compose still interpolates every service before it filters by profile, so the stack .env needs LITELLM_CONFIG
-# even though litellm never runs here. scripts/setup.mjs (providers/mem0/lib/stack-env.mjs) writes an inert value.
+# even when litellm does not run. scripts/setup.mjs (providers/mem0/lib/stack-env.mjs) writes the mem0 route file
+# when the option is on and an inert value otherwise.
 #
 # Loopback caveat (Linux): host.docker.internal resolves to the docker bridge gateway, not to the host's 127.0.0.1.
 # A mem0 server bound only to 127.0.0.1 is therefore NOT reachable from the indexer container. Bind it to 0.0.0.0
@@ -55,3 +60,20 @@ services:
         required: false
     extra_hosts:
       - "host.docker.internal:host-gateway"
+
+  # Only under the "litellm" profile (see the header). Loopback publish for a mem0 server running on this host.
+  litellm:
+    ports:
+      - "127.0.0.1:${MEM0_LITELLM_PORT:-4000}:4000"
+    # The port is reachable by every local user and process, so an unauthenticated proxy is not allowed: exit unless
+    # the env file supplies an sk- master key. The routes' general_settings.master_key then makes LiteLLM enforce it.
+    entrypoint:
+      - /bin/sh
+      - -c
+      - |
+        case "$${LITELLM_MASTER_KEY:-}" in
+          sk-?*) ;;
+          *) echo "litellm: LITELLM_MASTER_KEY=sk-... is missing from LITELLM_ENV_FILE; rerun ./setup" >&2; exit 1 ;;
+        esac
+        exec docker/prod_entrypoint.sh "$$@"
+      - litellm

package/providers/mem0/lib/coding-agent.mjs

@@ -1,5 +1,5 @@
 /**
- * Step "8. Coding-agent plugin", mem0 half: there is no npx pluginPackage for the
+ * Step "9. Coding-agent plugin", mem0 half: there is no npx pluginPackage for the
  * self-hosted REST server. Print concrete SDK / MCP / direct-REST paths, then
  * optionally merge the mem0 MCP into ~/.cursor/mcp.json (--yes or confirm).
  */

package/providers/mem0/lib/configure.mjs

@@ -7,6 +7,7 @@
 import path from "node:path";
 import { applyConfig, configToml } from "./config.mjs";
 import { dirTooOpen, fileMode, keyProblem, readKey, tooOpen, writeKey } from "./env-file.mjs";
+import { EMBED_BACKENDS, storedChoice } from "./litellm.mjs";
 import { capturedKey, captureKeyFromEnv } from "./secret.mjs";
 import { ensureState, envFileProblem, resolveEnvFile } from "./state.mjs";
 import { displayUrl, resolveApiUrl, urlProblem } from "./url.mjs";
@@ -130,6 +131,71 @@ export async function clackSetup(ctx, ui, h) {
   const handoff = { WIZARD_SKIP_BACKEND_STEP: "1", MEM0_API_URL: url };
   const key = String(secret || "").trim();
   if (key) handoff.PM_MEM0_API_KEY = key;
+  Object.assign(handoff, await clackLitellm(stub, ui, h));
   ui.note("Next: Docker, indexing, and starting the stack.", "mem0 configured");
   return handoff;
 }
+
+/**
+ * Clack questions for "route mem0's LLM through the stack LiteLLM". Returns the MEM0_LITELLM_*
+ * handoff (and ANTHROPIC_API_KEY when typed); the wizard step reads them under WIZARD_SKIP_BACKEND_STEP.
+ * @param {Record<string, any>} ctx
+ * @param {typeof import("@clack/prompts")} ui
+ * @param {Helpers} h
+ * @returns {Promise<Record<string, string>>}
+ */
+async function clackLitellm(ctx, ui, h) {
+  const exitIfCancel = (v) => {
+    if (ui.isCancel(v)) {
+      ui.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    return v;
+  };
+  const current = storedChoice(ctx, h);
+  const on = exitIfCancel(
+    await ui.confirm({
+      message: "Route mem0's LLM through the stack LiteLLM (same gateway as Hindsight; 127.0.0.1 only)?",
+      initialValue: current.enabled,
+    }),
+  );
+  if (!on) return { MEM0_LITELLM: "0" };
+  const backend = /** @type {string} */ (
+    exitIfCancel(
+      await ui.select({
+        message: "LiteLLM backend for mem0's LLM",
+        options: [
+          { value: "ollama", label: "Ollama", hint: "LLM and embeddings (nomic-embed-text)" },
+          { value: "custom", label: "Custom OpenAI-compatible URL", hint: "lemond, vLLM, OpenAI, ..." },
+          { value: "anthropic", label: "Anthropic API key", hint: "Claude; no embeddings" },
+          { value: "meridian", label: "Claude subscription (Meridian)", hint: "Anthropic Consumer Terms apply; no embeddings" },
+        ],
+        initialValue: current.backend,
+      }),
+    )
+  );
+  const c = storedChoice(ctx, h, backend);
+  /** @type {Record<string, string>} */
+  const out = { MEM0_LITELLM: "1", MEM0_LITELLM_BACKEND: backend };
+  if (backend === "ollama" || backend === "custom") {
+    out.MEM0_LITELLM_API_BASE = String(
+      exitIfCancel(await ui.text({ message: "Model server base URL (as the litellm container sees it)", placeholder: c.apiBase, defaultValue: c.apiBase })) || c.apiBase,
+    ).trim();
+  }
+  out.MEM0_LITELLM_MODEL = String(
+    exitIfCancel(await ui.text({ message: "Model id for mem0's LLM", placeholder: c.model, defaultValue: c.model })) || c.model,
+  ).trim();
+  if (EMBED_BACKENDS.includes(backend)) {
+    const def = c.embedModel || "none";
+    out.MEM0_LITELLM_EMBED_MODEL = String(
+      exitIfCancel(await ui.text({ message: "Embedding model through LiteLLM (none keeps mem0's own embedder)", placeholder: def, defaultValue: def })) || def,
+    ).trim();
+  }
+  if (backend === "anthropic") {
+    const secret = String(
+      exitIfCancel(await ui.password({ message: "ANTHROPIC_API_KEY for litellm.env (empty keeps the one there)" })) || "",
+    ).trim();
+    if (secret) out.PM_ANTHROPIC_API_KEY = secret;
+  }
+  return out;
+}