@bcmyguest/openmem 0.0.0-stage → 0.8.0

package/providers/hindsight/wizard.mjs

@@ -0,0 +1,150 @@
+/**
+ * Hindsight sub-wizard (hook API v2). Owns everything Hindsight-specific that the meta
+ * wizard used to do inline: the lemond / Ollama / custom model flow and LiteLLM routes,
+ * hindsight.env and litellm.env, the HINDSIGHT_PORT / HINDSIGHT_CP_PORT pair, Hindsight
+ * validation, and the summary lines. See lib/ for the implementations and
+ * docs/provider-wizard-hooks.md for the hook contract.
+ *
+ * This module must not import wizard/lib/run-wizard.mjs; it receives `helpers`.
+ */
+import { applyConfigEnv, configToml as buildConfigToml } from "./lib/config.mjs";
+import { setupCodingAgent as linkCodingAgent } from "./lib/coding-agent.mjs";
+import { clackSetup as askInClack } from "./lib/clack.mjs";
+import { setupEnv as setupHindsightEnv, stackEnv as hindsightStackEnv } from "./lib/env-setup.mjs";
+import { chooseModelBackend } from "./lib/model-backend.mjs";
+import { ensureComposeOllamaModels } from "./lib/ollama-compose.mjs";
+import { resolvePorts as resolveHindsightPorts } from "./lib/ports.mjs";
+import { backendDefault, confGet, ensureState } from "./lib/state.mjs";
+import { summary as hindsightSummary } from "./lib/summary.mjs";
+import { validateHindsight } from "./lib/validate.mjs";
+
+// Called by scripts/setup.mjs (the stack .env writer), not by the wizard.
+export { migrateEnv, prepareStackEnv, setupNotices } from "./lib/stack-env.mjs";
+
+/** @typedef {import('../../wizard/lib/provider-wizard/helpers.mjs').ProviderWizardHelpers} Helpers */
+
+/**
+ * Quiet: fill Hindsight's context fields, map [stack]/[model] TOML defaults into the
+ * environment (including LEMOND_BASE from [model].lemond.host).
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function init(ctx, h) {
+  ensureState(ctx);
+  applyConfigEnv(ctx.pmMerged || {});
+  if (process.env.LEMOND_BASE) ctx.lemondBase = process.env.LEMOND_BASE;
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function afterProvider(ctx, h) {
+  h.info("Hindsight uses LiteLLM aliases (memory-retain / reflect / consolidate).");
+}
+
+/**
+ * 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
+ */
+export async function configureModelRouting(ctx, h) {
+  await chooseModelBackend(ctx, h);
+}
+
+/** Hindsight's API and control-plane ports. */
+export const resolvePorts = resolveHindsightPorts;
+
+/**
+ * Quiet: description and environment for the stack setup script (scripts/setup.mjs).
+ * @param {Record<string, any>} ctx
+ */
+export function stackEnv(ctx) {
+  return hindsightStackEnv(ctx);
+}
+
+/** hindsight.env, litellm.env wiring. */
+export const setupEnv = setupHindsightEnv;
+
+/**
+ * Quiet: reload the model choice from wizard.conf for `--up`.
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function hydrate(ctx, h) {
+  ensureState(ctx);
+  ctx.backend = confGet(ctx, h, "MEMORY_BACKEND") || backendDefault(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);
+}
+
+/**
+ * Ensure compose profile `ollama` is on the up command when MEMORY_OLLAMA_IN_COMPOSE=1.
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} _h
+ */
+export async function beforeStack(ctx, _h) {
+  ensureState(ctx);
+  applyComposeProfiles(ctx);
+}
+
+/**
+ * Pull models into compose Ollama after the stack is up (host has no ollama CLI).
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function afterStackHealthy(ctx, h) {
+  await ensureComposeOllamaModels(ctx, h);
+}
+
+/** @param {Record<string, any>} ctx */
+function applyComposeProfiles(ctx) {
+  const extra = [...(ctx.extraComposeProfiles || [])];
+  if (ctx.ollamaInCompose && !extra.includes("ollama")) extra.push("ollama");
+  ctx.extraComposeProfiles = extra;
+}
+
+/**
+ * Quiet: tables merged into config.toml.
+ * @param {Record<string, any>} ctx
+ */
+export function configToml(ctx) {
+  ensureState(ctx);
+  return buildConfigToml(ctx);
+}
+
+/**
+ * Quiet: lines for the closing summary.
+ * @param {Record<string, any>} ctx
+ */
+export function summary(ctx) {
+  return hindsightSummary(ctx);
+}
+
+/**
+ * Appends to ctx.validationErrors / ctx.validationChecks after the shared checks.
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function extendValidation(ctx, h) {
+  validateHindsight(ctx, h);
+}
+
+/** Link ~/.hindsight/coding-agent.json and check optInPaths. */
+export const setupCodingAgent = linkCodingAgent;
+
+/**
+ * Clack-only: ask the model questions, return the environment that makes the wizard
+ * skip its own (see WIZARD_SKIP_BACKEND_STEP).
+ * @param {Record<string, any>} ctx
+ * @param {typeof import("@clack/prompts")} ui
+ * @param {Helpers} h
+ */
+export async function clackSetup(ctx, ui, h) {
+  return askInClack(ctx, ui, h);
+}

package/providers/letta/manifest.json

@@ -0,0 +1,29 @@
+{
+  "id": "letta",
+  "label": "Letta",
+  "status": "planned",
+  "notes": "Placeholder manifest. Letta (formerly MemGPT) server integration is not wired; track via issues before changing status.",
+  "settings": {
+    "nativeDocs": "https://docs.letta.com/",
+    "nativeConfigPaths": [],
+    "wizardOwns": []
+  },
+  "compose": {
+    "profile": "letta",
+    "files": [],
+    "services": [],
+    "healthService": null,
+    "healthPath": null,
+    "hostPortEnv": null,
+    "defaultHostPort": null
+  },
+  "indexer": {
+    "apiUrlEnv": "LETTA_API_URL",
+    "sink": "letta"
+  },
+  "codingAgent": {
+    "pluginPackage": null,
+    "configTemplate": null
+  },
+  "wizard": {}
+}

package/providers/mem0/OPERATOR.md

@@ -0,0 +1,143 @@
+# mem0 operator runbook (URL-only)
+
+This stack does **not** run a mem0 container. You run a [self-hosted mem0 REST
+server](https://docs.mem0.ai/open-source/features/rest-api); `./setup` only points
+the shared indexer at it.
+
+**Not** the hosted platform at `https://api.mem0.ai`. That API shape differs
+(`/v1/…`); the indexer sink and wizard smoke talk to the open-source REST
+server only (no `/v1/` prefix).
+
+## What `./setup` owns vs what you own
+
+| You (provider-native) | This stack |
+| --- | --- |
+| Start the mem0 REST server (JWT, Postgres/pgvector, dashboard) | Write `MEM0_API_URL` / `MEM0_INDEXER_URL` into the stack `.env` |
+| 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
+
+- **`MEM0_API_URL`** — host view (what you curl from this machine), e.g.
+  `http://127.0.0.1:18888`. Default port in the manifest is **18888**.
+- **`MEM0_INDEXER_URL`** — container view. `./setup` derives it from
+  `MEM0_API_URL` by rewriting loopback hosts (`127.0.0.1`, `localhost`,
+  `0.0.0.0`, `[::1]`) to `host.docker.internal`. Do not hand-edit it to
+  `127.0.0.1` inside the container; validation requires it to match that rewrite.
+
+## Linux loopback
+
+`host.docker.internal` is the docker bridge gateway, **not** the host's
+`127.0.0.1`. A mem0 process bound only to `127.0.0.1` is unreachable from the
+indexer container. Bind the server to `0.0.0.0` (or the bridge IP), or put a
+real hostname in `MEM0_API_URL`. An `https://localhost` URL becomes
+`https://host.docker.internal`, which usually fails TLS name checks — use a
+hostname the certificate covers.
+
+## API key file
+
+```text
+~/.config/personal-memory/mem0.env   # mode 600; directory mode 700
+MEM0_API_KEY=<key>
+```
+
+Never put `MEM0_API_KEY` in the stack `.env` (mode 644), `wizard.conf`, or
+`config.toml`. Override the path with `MEM0_ENV_FILE` / `[memory.mem0] env_file`
+if needed; then `./setup` must record that path in the stack `.env`.
+
+With **`AUTH_DISABLED=true`** on the server (development only), no key is
+required. Auth-enabled servers need a key or smoke/indexer calls return 401.
+
+## Embedder
+
+Search fails if the server's embedder is misconfigured. Smoke looks for the
+fact stored with `infer: false`; a miss points at the embedder key and server
+logs, not at this stack.
+
+## Cleartext keys
+
+Over plain `http://` to a non-loopback host, `X-API-Key` travels in cleartext.
+Prefer `https://`, or keep the server on loopback / the same host.
+
+## Coding agents
+
+There is no `pluginPackage`. Agents talk to your server via the Python SDK,
+the self-hosted MCP bridge, or direct REST (`POST /memories`, `POST /search`). The
+wizard's coding-agent step prints those paths and can register Cursor MCP; see
+`providers/mem0/lib/coding-agent.mjs`.
+
+### Cursor MCP (`~/.cursor/mcp.json`)
+
+Mem0's official MCP (`https://mcp.mem0.ai`) is **platform/cloud only**. For a
+self-hosted REST server this repo registers [`@yeyuan98/mem0-mcp`](https://www.npmjs.com/package/@yeyuan98/mem0-mcp)
+via the launcher `cli/mem0-mcp.mjs` (loads the key from the env file, then
+`npx -y @yeyuan98/mem0-mcp`).
+
+```sh
+MEMORY_PROVIDER=mem0 npx openmem install-mcp --yes
+# checkout: MEMORY_PROVIDER=mem0 node cli/openmem.mjs install-mcp --yes
+# or accept the coding-agent MCP confirm in setup
+```
+
+Shape written (URL and env-file **path** only — never the key value):
+
+```json
+{
+  "mcpServers": {
+    "mem0": {
+      "command": "node",
+      "args": ["/path/to/openmem/cli/mem0-mcp.mjs"],
+      "env": {
+        "MEM0_API_URL": "http://127.0.0.1:18888",
+        "MEM0_BASE_URL": "http://127.0.0.1:18888",
+        "MEM0_ENV_FILE": "~/.config/personal-memory/mem0.env"
+      }
+    }
+  }
+}
+```
+
+**API key:** the launcher reads `MEM0_API_KEY` from `MEM0_ENV_FILE` when the
+variable is not already in the process environment. You can also
+`export MEM0_API_KEY=…` (e.g. `set -a; source ~/.config/personal-memory/mem0.env; set +a`)
+before starting Cursor so the agent inherits it. **Never** put `MEM0_API_KEY` in
+`mcp.json`. Existing `hindsight` / `codegraph` / `notebooklm` servers are left alone.
+
+Restart Cursor Agent after install.
+
+### Switch to / from mem0
+
+```sh
+npx openmem switch mem0 --yes
+# later: npx openmem switch hindsight --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

@@ -0,0 +1,79 @@
+# mem0 compose fragment (URL-only mode). Layered over compose.yaml; the wizard passes both, then `up -d`:
+#   docker compose -f compose.yaml -f providers/mem0/compose.yaml --profile mem0 up -d
+# Add `-f compose.override.yaml` when you use the generated secret masks (Compose skips that file once -f is given).
+#
+# URL-only: this fragment defines NO service. The indexer talks to a mem0 REST server you already run (usually on
+# the host, or on another machine); nothing here starts, builds or pulls a mem0 container. The reason is that the
+# current self-hosted mem0 server (JWT/API-key auth, dashboard, Postgres + pgvector) has no current published image:
+# `mem0/mem0-api-server:latest` on Docker Hub predates the auth. A mem0 service is a documented follow-up: build
+# `server/` from a pinned mem0 git ref next to `pgvector/pgvector:pg17`, pinned and verified. Until then there is no
+# `mem0` profile service, so `--profile mem0` only selects this fragment; it starts the provider-neutral indexer
+# and its state-init step and nothing else.
+#
+# 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.
+#   - `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 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
+# or to the docker bridge IP, or give MEM0_API_URL a real hostname. An https://localhost URL is rewritten to
+# https://host.docker.internal, which will not match the server certificate name (use a hostname the certificate
+# covers). ./setup prints a note when MEM0_API_URL is a loopback address.
+#
+# Stack .env keys read here (written by ./setup):
+#   MEM0_INDEXER_URL  the server as the indexer container sees it. The wizard derives it from MEM0_API_URL (the host
+#                     view) by rewriting localhost, 127.0.0.1, 0.0.0.0 and [::1] to host.docker.internal.
+#   MEM0_ENV_FILE     optional; default ~/.config/personal-memory/mem0.env. Holds ONLY MEM0_API_KEY=... for the
+#                     indexer (mode 600, outside the repo). Not needed when the server runs with AUTH_DISABLED.
+#                     mem0's own server secrets (JWT_SECRET, ADMIN_API_KEY, embedder keys) are the operator's concern
+#                     and never go through this stack.
+
+services:
+  indexer:
+    environment:
+      # Selects indexer/sinks/mem0.py and gives it the server URL (container view, not the host view).
+      MEMORY_SINK: mem0
+      MEMORY_API_URL: ${MEM0_INDEXER_URL:?run ./setup (mem0 API URL)}
+    # required: false lets `config` and `up` run before the key file exists (Compose 2.24+).
+    env_file:
+      - path: ${MEM0_ENV_FILE:-${HOME}/.config/personal-memory/mem0.env}
+        required: false
+    # Reach a server on the host through host.docker.internal.
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    # No depends_on: the server is external, and the indexer's watcher retries until it answers.
+
+  notebooklm:
+    environment:
+      MEMORY_SINK: mem0
+      MEMORY_API_URL: ${MEM0_INDEXER_URL:?run ./setup (mem0 API URL)}
+    env_file:
+      - path: ${MEM0_ENV_FILE:-${HOME}/.config/personal-memory/mem0.env}
+        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

@@ -0,0 +1,58 @@
+/**
+ * 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).
+ */
+import { installMem0Mcp } from "./mcp-install.mjs";
+import { ensureState } from "./state.mjs";
+import { displayUrl, resolveApiUrl, urlProblem } from "./url.mjs";
+
+/** @typedef {import("../../../wizard/lib/provider-wizard/helpers.mjs").ProviderWizardHelpers} Helpers */
+
+const SDK_DOCS = "https://docs.mem0.ai/open-source/python-quickstart";
+const MCP_PACKAGE = "https://www.npmjs.com/package/@yeyuan98/mem0-mcp";
+const REST_DOCS = "https://docs.mem0.ai/open-source/features/rest-api";
+const OPERATOR = "providers/mem0/OPERATOR.md";
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function setupCodingAgent(ctx, h) {
+  ensureState(ctx);
+  const raw = resolveApiUrl(ctx, h);
+  const base = urlProblem(raw) ? "(set MEM0_API_URL)" : displayUrl(raw);
+
+  h.info("mem0 has no coding-agent pluginPackage; use the self-hosted server directly:");
+  h.info(`  1. SDK  — pip install mem0ai, point Memory at ${base} (see ${SDK_DOCS})`);
+  h.info(
+    `  2. MCP  — MEMORY_PROVIDER=mem0 npm run install-mcp -- --yes` +
+      ` (npx @yeyuan98/mem0-mcp via cli/mem0-mcp.mjs; see ${MCP_PACKAGE} and ${OPERATOR})`,
+  );
+  h.info(
+    `  3. REST — POST ${base}/memories and POST ${base}/search with X-API-Key` +
+      ` (see ${REST_DOCS}; stack wiring in ${OPERATOR})`,
+  );
+
+  const codeRoot = ctx.packageRoot || ctx.repoRoot;
+  const stackRoot = ctx.repoRoot;
+  const wantMcp =
+    Boolean(ctx.yes) ||
+    (await h.confirm(ctx, "Register mem0 MCP in ~/.cursor/mcp.json now?", "y"));
+  if (wantMcp) {
+    await installMem0Mcp(
+      {
+        home: ctx.home,
+        repoRoot: codeRoot,
+        stackRoot,
+        dry: Boolean(ctx.dry),
+        env: process.env,
+      },
+      h,
+    );
+  } else {
+    h.info("skip MCP merge; later: MEMORY_PROVIDER=mem0 npm run install-mcp -- --yes");
+  }
+
+  h.ok("coding-agent: documented SDK / MCP / REST paths (pluginPackage remains null)");
+}

package/providers/mem0/lib/config.mjs

@@ -0,0 +1,45 @@
+/**
+ * mem0's slice of ~/.config/personal-memory/config.toml: the [memory.mem0] table
+ * (api_url, optional env_file). Never a key.
+ */
+import { ensureState } from "./state.mjs";
+
+/**
+ * @param {Record<string, unknown>} cfg merged TOML config
+ * @returns {{ apiUrl: string, envFile: string }}
+ */
+export function defaultsFromConfig(cfg) {
+  const memory = /** @type {Record<string, unknown>} */ (cfg?.memory || {});
+  const mem0 = /** @type {Record<string, unknown>} */ (memory.mem0 || {});
+  return {
+    apiUrl: mem0.api_url != null ? String(mem0.api_url).trim() : "",
+    envFile: mem0.env_file != null ? String(mem0.env_file).trim() : "",
+  };
+}
+
+/**
+ * Seed ctx.mem0 from [memory.mem0]. Env vars still win over these (see resolveApiUrl).
+ * @param {Record<string, any>} ctx
+ */
+export function applyConfig(ctx) {
+  const state = ensureState(ctx);
+  const d = defaultsFromConfig(ctx.pmMerged || {});
+  if (d.apiUrl && !state.apiUrl) state.apiUrl = d.apiUrl;
+  if (d.envFile && !state.tomlEnvFile) state.tomlEnvFile = d.envFile;
+}
+
+/**
+ * Tables merged into config.toml: `memory.mem0`, which the wizard merges into [memory] (it
+ * always sets `provider` itself).
+ * @param {Record<string, any>} ctx
+ * @param {string} url the resolved host-view server URL
+ * @returns {Record<string, Record<string, unknown>>}
+ */
+export function configToml(ctx, url) {
+  const state = ensureState(ctx);
+  /** @type {Record<string, unknown>} */
+  const mem0 = { api_url: url };
+  const envFile = (process.env.MEM0_ENV_FILE || state.tomlEnvFile || "").trim();
+  if (envFile) mem0.env_file = envFile;
+  return { memory: { mem0 } };
+}