@tanstack/ai-memory 0.0.0

package/dist/esm/providers/in-memory/index.js

@@ -0,0 +1,46 @@
+import { inspectRecords, isExpired, listRecordFacts, recallRecords, sameScope, saveTurn } from "../../internal/store.js";
+//#region src/providers/in-memory/index.ts
+/**
+* Zero-dependency memory adapter backed by a `Map`. Records vanish on process
+* restart, so this is for local development, tests, and single-process demos —
+* not multi-process production (each worker gets its own Map). For production,
+* use {@link redis} from `@tanstack/ai-memory/redis`.
+*
+* By default `save` stores the raw user/assistant turn and `recall` scores it
+* lexically + by recency. Pass an `embedder` for semantic scoring and/or an
+* `extract` function to persist derived facts.
+*/
+function inMemory(options = {}) {
+	const records = /* @__PURE__ */ new Map();
+	function sweep() {
+		const now = Date.now();
+		const live = [];
+		for (const r of records.values()) if (isExpired(r, now)) records.delete(r.id);
+		else live.push(r);
+		return live;
+	}
+	const store = {
+		async add(batch) {
+			const now = Date.now();
+			for (const r of batch) records.set(r.id, {
+				...r,
+				updatedAt: now
+			});
+			sweep();
+		},
+		async loadScope(scope) {
+			return sweep().filter((r) => sameScope(r.scope, scope));
+		}
+	};
+	return {
+		id: "in-memory",
+		recall: (scope, query) => recallRecords(store, scope, query, options),
+		save: (scope, turn) => saveTurn(store, scope, turn, options),
+		inspect: (scope) => inspectRecords(store, scope),
+		listFacts: (scope) => listRecordFacts(store, scope)
+	};
+}
+//#endregion
+export { inMemory };
+
+//# sourceMappingURL=index.js.map

package/dist/esm/providers/in-memory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/providers/in-memory/index.ts"],"sourcesContent":["import {\n  inspectRecords,\n  isExpired,\n  listRecordFacts,\n  recallRecords,\n  sameScope,\n  saveTurn,\n} from '../../internal/store'\nimport type {\n  BuiltinOptions,\n  MemoryRecord,\n  RecordStore,\n} from '../../internal/store'\nimport type { MemoryAdapter, MemoryScope } from '../../types'\n\n/**\n * Options for {@link inMemory}. Retrieval/extraction knobs that used to live on\n * the middleware are adapter options here.\n */\nexport interface InMemoryOptions extends BuiltinOptions {}\n\n/**\n * Zero-dependency memory adapter backed by a `Map`. Records vanish on process\n * restart, so this is for local development, tests, and single-process demos —\n * not multi-process production (each worker gets its own Map). For production,\n * use {@link redis} from `@tanstack/ai-memory/redis`.\n *\n * By default `save` stores the raw user/assistant turn and `recall` scores it\n * lexically + by recency. Pass an `embedder` for semantic scoring and/or an\n * `extract` function to persist derived facts.\n */\nexport function inMemory(options: InMemoryOptions = {}): MemoryAdapter {\n  const records = new Map<string, MemoryRecord>()\n\n  function sweep(): Array<MemoryRecord> {\n    const now = Date.now()\n    const live: Array<MemoryRecord> = []\n    for (const r of records.values()) {\n      if (isExpired(r, now)) records.delete(r.id)\n      else live.push(r)\n    }\n    return live\n  }\n\n  const store: RecordStore = {\n    async add(batch) {\n      const now = Date.now()\n      for (const r of batch) records.set(r.id, { ...r, updatedAt: now })\n      sweep()\n    },\n    async loadScope(scope: MemoryScope) {\n      return sweep().filter((r) => sameScope(r.scope, scope))\n    },\n  }\n\n  return {\n    id: 'in-memory',\n    recall: (scope, query) => recallRecords(store, scope, query, options),\n    save: (scope, turn) => saveTurn(store, scope, turn, options),\n    inspect: (scope) => inspectRecords(store, scope),\n    listFacts: (scope) => listRecordFacts(store, scope),\n  }\n}\n"],"mappings":";;;;;;;;;;;;AA+BA,SAAgB,SAAS,UAA2B,CAAC,GAAkB;CACrE,MAAM,0BAAU,IAAI,IAA0B;CAE9C,SAAS,QAA6B;EACpC,MAAM,MAAM,KAAK,IAAI;EACrB,MAAM,OAA4B,CAAC;EACnC,KAAK,MAAM,KAAK,QAAQ,OAAO,GAC7B,IAAI,UAAU,GAAG,GAAG,GAAG,QAAQ,OAAO,EAAE,EAAE;OACrC,KAAK,KAAK,CAAC;EAElB,OAAO;CACT;CAEA,MAAM,QAAqB;EACzB,MAAM,IAAI,OAAO;GACf,MAAM,MAAM,KAAK,IAAI;GACrB,KAAK,MAAM,KAAK,OAAO,QAAQ,IAAI,EAAE,IAAI;IAAE,GAAG;IAAG,WAAW;GAAI,CAAC;GACjE,MAAM;EACR;EACA,MAAM,UAAU,OAAoB;GAClC,OAAO,MAAM,CAAC,CAAC,QAAQ,MAAM,UAAU,EAAE,OAAO,KAAK,CAAC;EACxD;CACF;CAEA,OAAO;EACL,IAAI;EACJ,SAAS,OAAO,UAAU,cAAc,OAAO,OAAO,OAAO,OAAO;EACpE,OAAO,OAAO,SAAS,SAAS,OAAO,OAAO,MAAM,OAAO;EAC3D,UAAU,UAAU,eAAe,OAAO,KAAK;EAC/C,YAAY,UAAU,gBAAgB,OAAO,KAAK;CACpD;AACF"}

package/dist/esm/providers/mem0/index.d.ts

@@ -0,0 +1,14 @@
+import { MemoryAdapter } from '../../types.js';
+export interface Mem0Options {
+    /** Durable user id. Falls back to `scope.userId`, then `'demo-user'`. */
+    user?: string;
+    /** mem0 server URL. Defaults to `MEM0_URL` or `http://localhost:8000`. */
+    baseUrl?: string;
+    /** Bearer token. Defaults to `MEM0_ADMIN_API_KEY`. */
+    apiKey?: string;
+    /** Ask mem0 to rerank search results. Defaults to `true`. */
+    rerank?: boolean;
+    /** Minimum search score. Defaults to `0.1`. */
+    threshold?: number;
+}
+export declare function mem0(options?: Mem0Options): MemoryAdapter;

package/dist/esm/providers/mem0/index.js

@@ -0,0 +1,150 @@
+//#region src/providers/mem0/index.ts
+function asRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Pull the array of items out of a mem0 response (`{results: []}` or a bare array). */
+function itemsOf(data) {
+	const rec = asRecord(data);
+	const candidate = rec && "results" in rec ? rec.results : data;
+	if (!Array.isArray(candidate)) return [];
+	return candidate.filter((m) => !!m && typeof m === "object");
+}
+function mem0(options = {}) {
+	const baseUrl = options.baseUrl ?? process.env.MEM0_URL ?? "http://localhost:8000";
+	const apiKey = options.apiKey ?? process.env.MEM0_ADMIN_API_KEY ?? "";
+	const rerank = options.rerank ?? true;
+	const threshold = options.threshold ?? .1;
+	function headers() {
+		const h = { "Content-Type": "application/json" };
+		if (apiKey) h.Authorization = `Bearer ${apiKey}`;
+		return h;
+	}
+	function userId(scope) {
+		return options.user ?? scope.userId ?? "demo-user";
+	}
+	/**
+	* mem0 `run_id` — conversation/run isolation. Maps 1:1 to `scope.threadId` so
+	* same-user memories do not leak across threads.
+	*/
+	function runId(scope) {
+		return scope.threadId;
+	}
+	async function safeJson(fn) {
+		const start = Date.now();
+		try {
+			const res = await fn();
+			const latencyMs = Date.now() - start;
+			if (!res.ok) {
+				const text = await res.text().catch(() => "");
+				return {
+					ok: false,
+					latencyMs,
+					error: `HTTP ${res.status}: ${text.slice(0, 300)}`
+				};
+			}
+			return {
+				ok: true,
+				latencyMs,
+				data: await res.json().catch(() => null)
+			};
+		} catch (err) {
+			return {
+				ok: false,
+				latencyMs: Date.now() - start,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	async function loadMemories(scope) {
+		const params = new URLSearchParams({
+			user_id: userId(scope),
+			run_id: runId(scope)
+		});
+		const url = `${baseUrl}/memories?${params.toString()}`;
+		return safeJson(() => fetch(url, {
+			method: "GET",
+			headers: headers()
+		}));
+	}
+	return {
+		id: "mem0",
+		async save(scope, turn) {
+			const result = await safeJson(() => fetch(`${baseUrl}/memories`, {
+				method: "POST",
+				headers: headers(),
+				body: JSON.stringify({
+					messages: [{
+						role: "user",
+						content: turn.user
+					}, {
+						role: "assistant",
+						content: turn.assistant
+					}],
+					user_id: userId(scope),
+					run_id: runId(scope)
+				})
+			}));
+			return [{
+				ok: result.ok,
+				latencyMs: result.latencyMs,
+				raw: result.ok ? result.data : void 0,
+				error: result.ok ? void 0 : result.error
+			}];
+		},
+		async recall(scope, query) {
+			const result = await safeJson(() => fetch(`${baseUrl}/search`, {
+				method: "POST",
+				headers: headers(),
+				body: JSON.stringify({
+					query,
+					user_id: userId(scope),
+					run_id: runId(scope),
+					rerank,
+					threshold
+				})
+			}));
+			if (!result.ok) return {
+				systemPrompt: "",
+				fragments: [],
+				raw: { error: result.error }
+			};
+			const fragments = itemsOf(result.data).map((m) => ({
+				text: asString(m.memory) ?? asString(m.text) ?? JSON.stringify(m),
+				source: asString(m.id) ?? "mem0"
+			}));
+			return {
+				systemPrompt: fragments.length === 0 ? "" : `Recalled memory:\n${fragments.map((f) => `- (${f.source}) ${f.text}`).join("\n")}`,
+				fragments,
+				raw: result.data
+			};
+		},
+		async inspect(scope) {
+			const result = await loadMemories(scope);
+			return {
+				takenAt: (/* @__PURE__ */ new Date()).toISOString(),
+				data: result.ok ? result.data : { error: result.error }
+			};
+		},
+		async listFacts(scope) {
+			const result = await loadMemories(scope);
+			if (!result.ok) return [];
+			return itemsOf(result.data).map((m) => {
+				const text = asString(m.memory);
+				if (!text) return null;
+				return {
+					id: asString(m.id) ?? "mem0",
+					text,
+					source: "memory",
+					createdAt: asString(m.updated_at) ?? asString(m.created_at)
+				};
+			}).filter((f) => f !== null);
+		}
+	};
+}
+//#endregion
+export { mem0 };
+
+//# sourceMappingURL=index.js.map

package/dist/esm/providers/mem0/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/providers/mem0/index.ts"],"sourcesContent":["/**\n * mem0 memory adapter — talks to a mem0 server over plain HTTP (no SDK, so no\n * peer dependency). mem0 owns extraction and ranking server-side; this adapter\n * maps the `recall`/`save` contract onto its `/memories` and `/search` endpoints.\n *\n * Requires a running mem0 server. Point it at one via `baseUrl` (or the\n * `MEM0_URL` env var); pass `apiKey` (or `MEM0_ADMIN_API_KEY`) when it's secured.\n */\n\nimport type {\n  MemoryAdapter,\n  MemoryFact,\n  MemoryFragment,\n  MemoryScope,\n  MemorySnapshot,\n  MemoryTurn,\n  RecallResult,\n  SaveReceipt,\n} from '../../types'\n\nexport interface Mem0Options {\n  /** Durable user id. Falls back to `scope.userId`, then `'demo-user'`. */\n  user?: string\n  /** mem0 server URL. Defaults to `MEM0_URL` or `http://localhost:8000`. */\n  baseUrl?: string\n  /** Bearer token. Defaults to `MEM0_ADMIN_API_KEY`. */\n  apiKey?: string\n  /** Ask mem0 to rerank search results. Defaults to `true`. */\n  rerank?: boolean\n  /** Minimum search score. Defaults to `0.1`. */\n  threshold?: number\n}\n\ntype JsonResult =\n  | { ok: true; latencyMs: number; data: unknown }\n  | { ok: false; latencyMs: number; error: string }\n\nfunction asRecord(value: unknown): Record<string, unknown> | undefined {\n  return value && typeof value === 'object'\n    ? (value as Record<string, unknown>)\n    : undefined\n}\n\nfunction asString(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined\n}\n\n/** Pull the array of items out of a mem0 response (`{results: []}` or a bare array). */\nfunction itemsOf(data: unknown): Array<Record<string, unknown>> {\n  const rec = asRecord(data)\n  const candidate = rec && 'results' in rec ? rec.results : data\n  if (!Array.isArray(candidate)) return []\n  return candidate.filter(\n    (m): m is Record<string, unknown> => !!m && typeof m === 'object',\n  )\n}\n\nexport function mem0(options: Mem0Options = {}): MemoryAdapter {\n  const baseUrl =\n    options.baseUrl ?? process.env.MEM0_URL ?? 'http://localhost:8000'\n  const apiKey = options.apiKey ?? process.env.MEM0_ADMIN_API_KEY ?? ''\n  const rerank = options.rerank ?? true\n  const threshold = options.threshold ?? 0.1\n\n  function headers(): Record<string, string> {\n    const h: Record<string, string> = { 'Content-Type': 'application/json' }\n    if (apiKey) h.Authorization = `Bearer ${apiKey}`\n    return h\n  }\n\n  function userId(scope: MemoryScope): string {\n    return options.user ?? scope.userId ?? 'demo-user'\n  }\n\n  /**\n   * mem0 `run_id` — conversation/run isolation. Maps 1:1 to `scope.threadId` so\n   * same-user memories do not leak across threads.\n   */\n  function runId(scope: MemoryScope): string {\n    return scope.threadId\n  }\n\n  async function safeJson(fn: () => Promise<Response>): Promise<JsonResult> {\n    const start = Date.now()\n    try {\n      const res = await fn()\n      const latencyMs = Date.now() - start\n      if (!res.ok) {\n        const text = await res.text().catch(() => '')\n        return {\n          ok: false,\n          latencyMs,\n          error: `HTTP ${res.status}: ${text.slice(0, 300)}`,\n        }\n      }\n      const data = await res.json().catch(() => null)\n      return { ok: true, latencyMs, data }\n    } catch (err) {\n      return {\n        ok: false,\n        latencyMs: Date.now() - start,\n        error: err instanceof Error ? err.message : String(err),\n      }\n    }\n  }\n\n  async function loadMemories(scope: MemoryScope): Promise<JsonResult> {\n    const params = new URLSearchParams({\n      user_id: userId(scope),\n      run_id: runId(scope),\n    })\n    const url = `${baseUrl}/memories?${params.toString()}`\n    return safeJson(() => fetch(url, { method: 'GET', headers: headers() }))\n  }\n\n  return {\n    id: 'mem0',\n\n    async save(scope, turn: MemoryTurn): Promise<Array<SaveReceipt>> {\n      const result = await safeJson(() =>\n        fetch(`${baseUrl}/memories`, {\n          method: 'POST',\n          headers: headers(),\n          body: JSON.stringify({\n            messages: [\n              { role: 'user', content: turn.user },\n              { role: 'assistant', content: turn.assistant },\n            ],\n            user_id: userId(scope),\n            run_id: runId(scope),\n          }),\n        }),\n      )\n      return [\n        {\n          ok: result.ok,\n          latencyMs: result.latencyMs,\n          raw: result.ok ? result.data : undefined,\n          error: result.ok ? undefined : result.error,\n        },\n      ]\n    },\n\n    async recall(scope, query): Promise<RecallResult> {\n      const result = await safeJson(() =>\n        fetch(`${baseUrl}/search`, {\n          method: 'POST',\n          headers: headers(),\n          body: JSON.stringify({\n            query,\n            user_id: userId(scope),\n            run_id: runId(scope),\n            rerank,\n            threshold,\n          }),\n        }),\n      )\n      if (!result.ok) {\n        return { systemPrompt: '', fragments: [], raw: { error: result.error } }\n      }\n      const fragments: Array<MemoryFragment> = itemsOf(result.data).map(\n        (m) => ({\n          text: asString(m.memory) ?? asString(m.text) ?? JSON.stringify(m),\n          source: asString(m.id) ?? 'mem0',\n        }),\n      )\n      const systemPrompt =\n        fragments.length === 0\n          ? ''\n          : `Recalled memory:\\n${fragments.map((f) => `- (${f.source}) ${f.text}`).join('\\n')}`\n      return { systemPrompt, fragments, raw: result.data }\n    },\n\n    async inspect(scope): Promise<MemorySnapshot> {\n      const result = await loadMemories(scope)\n      return {\n        takenAt: new Date().toISOString(),\n        data: result.ok ? result.data : { error: result.error },\n      }\n    },\n\n    async listFacts(scope): Promise<Array<MemoryFact>> {\n      const result = await loadMemories(scope)\n      if (!result.ok) return []\n      return itemsOf(result.data)\n        .map((m): MemoryFact | null => {\n          const text = asString(m.memory)\n          if (!text) return null\n          return {\n            id: asString(m.id) ?? 'mem0',\n            text,\n            source: 'memory',\n            createdAt: asString(m.updated_at) ?? asString(m.created_at),\n          }\n        })\n        .filter((f): f is MemoryFact => f !== null)\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/esm/providers/redis/index.d.ts

@@ -0,0 +1,54 @@
+import { BuiltinOptions } from '../../internal/store.js';
+import { MemoryAdapter } from '../../types.js';
+/**
+ * Minimal subset of the Redis client API the adapter uses. Shaped to match
+ * `ioredis` directly (lowercase method names). For node-redis v4+'s camelCase
+ * API, wrap the client with {@link fromNodeRedis}.
+ */
+export interface RedisLike {
+    set: (key: string, value: string) => Promise<unknown>;
+    get: (key: string) => Promise<string | null>;
+    del: (...keys: Array<string>) => Promise<unknown>;
+    sadd: (key: string, ...members: Array<string>) => Promise<unknown>;
+    srem: (key: string, ...members: Array<string>) => Promise<unknown>;
+    smembers: (key: string) => Promise<Array<string>>;
+    mget: (...keys: Array<string>) => Promise<Array<string | null>>;
+}
+/** node-redis v4+ default-mode (camelCase) surface used by {@link fromNodeRedis}. */
+export interface NodeRedisLike {
+    get: (key: string) => Promise<string | null>;
+    set: (key: string, value: string) => Promise<unknown>;
+    del: (keys: Array<string> | string) => Promise<number>;
+    sAdd: (key: string, members: string | Array<string>) => Promise<number>;
+    sRem: (key: string, members: string | Array<string>) => Promise<number>;
+    sMembers: (key: string) => Promise<Array<string>>;
+    mGet: (keys: Array<string>) => Promise<Array<string | null>>;
+}
+/**
+ * Wrap a node-redis v4+ default-mode client (camelCase API) into the lowercase
+ * {@link RedisLike} shape this adapter expects. For `ioredis`, no wrapper is
+ * needed — pass the client directly.
+ */
+export declare function fromNodeRedis(client: NodeRedisLike): RedisLike;
+export interface RedisOptions extends BuiltinOptions {
+    /** A Redis client implementing {@link RedisLike} (ioredis, or wrapped node-redis). */
+    redis: RedisLike;
+    /** Key prefix. Defaults to `'tanstack-ai:memory'`. */
+    prefix?: string;
+}
+/**
+ * Production memory adapter backed by plain Redis (no vector index required).
+ * Ranks client-side (lexical + optional cosine + recency + importance), so it's
+ * suited to up to ~10k records per scope. Bring your own client (`ioredis`, or
+ * node-redis wrapped with {@link fromNodeRedis}).
+ *
+ * Storage model:
+ * ```text
+ * {prefix}:record:{id}                                          -> JSON MemoryRecord
+ * {prefix}:index:{tenantId or _}:{userId or _}:{threadId}       -> Set<id>
+ * ```
+ * Segments are escaped (so `:`, `\\`, `_` in values cannot collide). Missing
+ * optional dims become `_` (omit ≠ match any — same exact-match model as the
+ * built-in `sameScope` helper). No dual-read of older index layouts.
+ */
+export declare function redis(options: RedisOptions): MemoryAdapter;

package/dist/esm/providers/redis/index.js

@@ -0,0 +1,118 @@
+import { inspectRecords, isExpired, listRecordFacts, recallRecords, saveTurn } from "../../internal/store.js";
+//#region src/providers/redis/index.ts
+/**
+* Wrap a node-redis v4+ default-mode client (camelCase API) into the lowercase
+* {@link RedisLike} shape this adapter expects. For `ioredis`, no wrapper is
+* needed — pass the client directly.
+*/
+function fromNodeRedis(client) {
+	return {
+		get: (key) => client.get(key),
+		set: (key, value) => client.set(key, value),
+		del: (...keys) => client.del(keys),
+		sadd: (key, ...members) => client.sAdd(key, members),
+		srem: (key, ...members) => client.sRem(key, members),
+		smembers: (key) => client.sMembers(key),
+		mget: (...keys) => client.mGet(keys)
+	};
+}
+/**
+* Escape the `:` scope-key delimiter (and the `\` escape character itself) in a
+* scope value before composing the colon-joined key. Without this, a scope
+* value containing `:` could shift segment positions and collide two different
+* scopes' index buckets. `_` is escaped too so a literal `_` value can't collide
+* with the unset-key placeholder.
+*/
+function escapeScopeValue(value) {
+	return value.replace(/[\\:_]/g, "\\$&");
+}
+var warnedMalformedIds = /* @__PURE__ */ new Set();
+var MALFORMED_WARN_CAP = 100;
+function warnMalformedRow(id, err) {
+	if (warnedMalformedIds.has(id) || warnedMalformedIds.size >= MALFORMED_WARN_CAP) return;
+	warnedMalformedIds.add(id);
+	console.warn(`[tanstack-ai-memory] redis: skipped malformed record JSON (id=${id}). The row is left in place (not deleted) in case it is recoverable. Reason: ${String(err)}`);
+}
+/**
+* Production memory adapter backed by plain Redis (no vector index required).
+* Ranks client-side (lexical + optional cosine + recency + importance), so it's
+* suited to up to ~10k records per scope. Bring your own client (`ioredis`, or
+* node-redis wrapped with {@link fromNodeRedis}).
+*
+* Storage model:
+* ```text
+* {prefix}:record:{id}                                          -> JSON MemoryRecord
+* {prefix}:index:{tenantId or _}:{userId or _}:{threadId}       -> Set<id>
+* ```
+* Segments are escaped (so `:`, `\\`, `_` in values cannot collide). Missing
+* optional dims become `_` (omit ≠ match any — same exact-match model as the
+* built-in `sameScope` helper). No dual-read of older index layouts.
+*/
+function redis(options) {
+	const client = options.redis;
+	const prefix = options.prefix ?? "tanstack-ai:memory";
+	const scopeKey = (scope) => {
+		const tenant = scope.tenantId != null && scope.tenantId !== "" ? scope.tenantId : "_";
+		const user = scope.userId != null && scope.userId !== "" ? scope.userId : "_";
+		return `${escapeScopeValue(tenant)}:${escapeScopeValue(user)}:${escapeScopeValue(scope.threadId)}`;
+	};
+	const indexKey = (scope) => `${prefix}:index:${scopeKey(scope)}`;
+	const recordKey = (id) => `${prefix}:record:${id}`;
+	const store = {
+		async add(batch) {
+			const now = Date.now();
+			for (const r of batch) {
+				const next = {
+					...r,
+					updatedAt: now
+				};
+				await client.set(recordKey(r.id), JSON.stringify(next));
+				await client.sadd(indexKey(r.scope), r.id);
+			}
+		},
+		async loadScope(scope) {
+			const idx = indexKey(scope);
+			const ids = await client.smembers(idx);
+			if (ids.length === 0) return [];
+			const raws = await client.mget(...ids.map(recordKey));
+			const out = [];
+			const stale = [];
+			for (let i = 0; i < raws.length; i++) {
+				const raw = raws[i];
+				const id = ids[i];
+				if (!raw) {
+					stale.push(id);
+					continue;
+				}
+				let record;
+				try {
+					record = JSON.parse(raw);
+				} catch (err) {
+					warnMalformedRow(id, err);
+					continue;
+				}
+				if (isExpired(record)) {
+					stale.push(id);
+					continue;
+				}
+				out.push(record);
+			}
+			if (stale.length > 0) {
+				await client.srem(idx, ...stale);
+				await client.del(...stale.map(recordKey));
+			}
+			return out;
+		}
+	};
+	return {
+		id: "redis",
+		recall: (scope, query) => recallRecords(store, scope, query, options),
+		save: (scope, turn) => saveTurn(store, scope, turn, options),
+		inspect: (scope) => inspectRecords(store, scope),
+		listFacts: (scope) => listRecordFacts(store, scope)
+	};
+}
+//#endregion
+export { fromNodeRedis, redis };
+
+//# sourceMappingURL=index.js.map

package/dist/esm/providers/redis/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/providers/redis/index.ts"],"sourcesContent":["import {\n  inspectRecords,\n  isExpired,\n  listRecordFacts,\n  recallRecords,\n  saveTurn,\n} from '../../internal/store'\nimport type {\n  BuiltinOptions,\n  MemoryRecord,\n  RecordStore,\n} from '../../internal/store'\nimport type { MemoryAdapter, MemoryScope } from '../../types'\n\n/**\n * Minimal subset of the Redis client API the adapter uses. Shaped to match\n * `ioredis` directly (lowercase method names). For node-redis v4+'s camelCase\n * API, wrap the client with {@link fromNodeRedis}.\n */\nexport interface RedisLike {\n  set: (key: string, value: string) => Promise<unknown>\n  get: (key: string) => Promise<string | null>\n  del: (...keys: Array<string>) => Promise<unknown>\n  sadd: (key: string, ...members: Array<string>) => Promise<unknown>\n  srem: (key: string, ...members: Array<string>) => Promise<unknown>\n  smembers: (key: string) => Promise<Array<string>>\n  mget: (...keys: Array<string>) => Promise<Array<string | null>>\n}\n\n/** node-redis v4+ default-mode (camelCase) surface used by {@link fromNodeRedis}. */\nexport interface NodeRedisLike {\n  get: (key: string) => Promise<string | null>\n  set: (key: string, value: string) => Promise<unknown>\n  del: (keys: Array<string> | string) => Promise<number>\n  sAdd: (key: string, members: string | Array<string>) => Promise<number>\n  sRem: (key: string, members: string | Array<string>) => Promise<number>\n  sMembers: (key: string) => Promise<Array<string>>\n  mGet: (keys: Array<string>) => Promise<Array<string | null>>\n}\n\n/**\n * Wrap a node-redis v4+ default-mode client (camelCase API) into the lowercase\n * {@link RedisLike} shape this adapter expects. For `ioredis`, no wrapper is\n * needed — pass the client directly.\n */\nexport function fromNodeRedis(client: NodeRedisLike): RedisLike {\n  return {\n    get: (key) => client.get(key),\n    set: (key, value) => client.set(key, value),\n    del: (...keys) => client.del(keys),\n    sadd: (key, ...members) => client.sAdd(key, members),\n    srem: (key, ...members) => client.sRem(key, members),\n    smembers: (key) => client.sMembers(key),\n    mget: (...keys) => client.mGet(keys),\n  }\n}\n\nexport interface RedisOptions extends BuiltinOptions {\n  /** A Redis client implementing {@link RedisLike} (ioredis, or wrapped node-redis). */\n  redis: RedisLike\n  /** Key prefix. Defaults to `'tanstack-ai:memory'`. */\n  prefix?: string\n}\n\n/**\n * Escape the `:` scope-key delimiter (and the `\\` escape character itself) in a\n * scope value before composing the colon-joined key. Without this, a scope\n * value containing `:` could shift segment positions and collide two different\n * scopes' index buckets. `_` is escaped too so a literal `_` value can't collide\n * with the unset-key placeholder.\n */\nfunction escapeScopeValue(value: string): string {\n  return value.replace(/[\\\\:_]/g, '\\\\$&')\n}\n\n// Track ids we've warned about so ongoing corruption of DIFFERENT ids keeps\n// surfacing, bounded so a pathological store can't spam the console forever.\nconst warnedMalformedIds = new Set<string>()\nconst MALFORMED_WARN_CAP = 100\nfunction warnMalformedRow(id: string, err: unknown): void {\n  if (\n    warnedMalformedIds.has(id) ||\n    warnedMalformedIds.size >= MALFORMED_WARN_CAP\n  ) {\n    return\n  }\n  warnedMalformedIds.add(id)\n  console.warn(\n    `[tanstack-ai-memory] redis: skipped malformed record JSON (id=${id}). ` +\n      `The row is left in place (not deleted) in case it is recoverable. ` +\n      `Reason: ${String(err)}`,\n  )\n}\n\n/**\n * Production memory adapter backed by plain Redis (no vector index required).\n * Ranks client-side (lexical + optional cosine + recency + importance), so it's\n * suited to up to ~10k records per scope. Bring your own client (`ioredis`, or\n * node-redis wrapped with {@link fromNodeRedis}).\n *\n * Storage model:\n * ```text\n * {prefix}:record:{id}                                          -> JSON MemoryRecord\n * {prefix}:index:{tenantId or _}:{userId or _}:{threadId}       -> Set<id>\n * ```\n * Segments are escaped (so `:`, `\\\\`, `_` in values cannot collide). Missing\n * optional dims become `_` (omit ≠ match any — same exact-match model as the\n * built-in `sameScope` helper). No dual-read of older index layouts.\n */\nexport function redis(options: RedisOptions): MemoryAdapter {\n  const client = options.redis\n  const prefix = options.prefix ?? 'tanstack-ai:memory'\n\n  const scopeKey = (scope: MemoryScope): string => {\n    const tenant =\n      scope.tenantId != null && scope.tenantId !== '' ? scope.tenantId : '_'\n    const user =\n      scope.userId != null && scope.userId !== '' ? scope.userId : '_'\n    return `${escapeScopeValue(tenant)}:${escapeScopeValue(user)}:${escapeScopeValue(scope.threadId)}`\n  }\n  const indexKey = (scope: MemoryScope): string =>\n    `${prefix}:index:${scopeKey(scope)}`\n  const recordKey = (id: string): string => `${prefix}:record:${id}`\n\n  const store: RecordStore = {\n    async add(batch) {\n      const now = Date.now()\n      for (const r of batch) {\n        const next: MemoryRecord = { ...r, updatedAt: now }\n        await client.set(recordKey(r.id), JSON.stringify(next))\n        await client.sadd(indexKey(r.scope), r.id)\n      }\n    },\n\n    async loadScope(scope: MemoryScope) {\n      const idx = indexKey(scope)\n      const ids = await client.smembers(idx)\n      if (ids.length === 0) return []\n      const raws = await client.mget(...ids.map(recordKey))\n      const out: Array<MemoryRecord> = []\n      const stale: Array<string> = []\n      for (let i = 0; i < raws.length; i++) {\n        const raw = raws[i] as string | null\n        const id = ids[i] as string\n        if (!raw) {\n          stale.push(id)\n          continue\n        }\n        let record: MemoryRecord\n        try {\n          record = JSON.parse(raw) as MemoryRecord\n        } catch (err) {\n          // Malformed JSON is skipped, NOT swept — a parse failure isn't proof\n          // the data is unrecoverable (truncated read, older schema, etc.).\n          warnMalformedRow(id, err)\n          continue\n        }\n        if (isExpired(record)) {\n          stale.push(id)\n          continue\n        }\n        out.push(record)\n      }\n      if (stale.length > 0) {\n        await client.srem(idx, ...stale)\n        await client.del(...stale.map(recordKey))\n      }\n      return out\n    },\n  }\n\n  return {\n    id: 'redis',\n    recall: (scope, query) => recallRecords(store, scope, query, options),\n    save: (scope, turn) => saveTurn(store, scope, turn, options),\n    inspect: (scope) => inspectRecords(store, scope),\n    listFacts: (scope) => listRecordFacts(store, scope),\n  }\n}\n"],"mappings":"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"}

package/dist/esm/types.d.ts

@@ -0,0 +1,112 @@
+import { Scope, Tool } from '@tanstack/ai';
+/**
+ * Isolation scope for memory reads and writes. Alias of the shared {@link Scope}
+ * identity type from `@tanstack/ai` so memory and persistence share one
+ * vocabulary (`threadId`, optional `userId` / `tenantId` / `namespace`).
+ *
+ * Opaque to the middleware — each adapter interprets it (vendors map it to
+ * bank/user ids; the built-in stores key their internal record space by it).
+ *
+ * Resolve every field server-side from trusted session/auth state. A client-
+ * originated `threadId` is only safe after you validate it belongs to the
+ * session user; never accept bare `userId`/`tenantId` from the request body.
+ */
+export type MemoryScope = Scope;
+/** A completed conversation turn handed to {@link MemoryAdapter.save}. */
+export interface MemoryTurn {
+    user: string;
+    assistant: string;
+}
+/** A discrete recalled item, when the adapter produces them. */
+export interface MemoryFragment {
+    /** The recalled text. */
+    text: string;
+    /** Provenance hint (record id, vendor result type, etc.). */
+    source: string;
+}
+/**
+ * Result of {@link MemoryAdapter.recall}. Everything the middleware needs to
+ * augment the run: a pre-rendered prompt block, optional discrete fragments,
+ * and optional tools the adapter wants exposed to the model this turn.
+ */
+export interface RecallResult {
+    /**
+     * Pre-rendered block to inject into the system prompt. An empty string means
+     * "nothing to inject" — the middleware skips it.
+     */
+    systemPrompt: string;
+    /**
+     * Discrete recalled items, when the adapter produces them. Omitted for
+     * engines that return synthesized output (e.g. honcho's dialectic answer).
+     */
+    fragments?: Array<MemoryFragment>;
+    /**
+     * Tools the adapter wants exposed to the model for this turn (e.g. hindsight's
+     * retain/recall/reflect tools). Merged into the run's tool set by the
+     * middleware. Omit or `[]` when the adapter exposes no tools.
+     */
+    tools?: Array<Tool>;
+    /**
+     * System-prompt text explaining when/how to use {@link RecallResult.tools}.
+     * Injected ahead of `systemPrompt`. Omit or `''` when there are no tools.
+     */
+    toolGuidance?: string;
+    /** Raw vendor payload, surfaced for devtools/inspection. */
+    raw?: unknown;
+}
+/**
+ * Receipt for a single underlying write performed by {@link MemoryAdapter.save}.
+ * One turn can produce several receipts (e.g. hindsight writes the user and
+ * assistant utterances separately), so `save` returns an array.
+ */
+export interface SaveReceipt {
+    ok: boolean;
+    /** Optional adapter-reported write latency (ms), for devtools. */
+    latencyMs?: number;
+    /** Present when `ok` is `false`. */
+    error?: string;
+    /** Raw vendor payload, surfaced for devtools/inspection. */
+    raw?: unknown;
+}
+/** Full snapshot returned by the optional {@link MemoryAdapter.inspect}. */
+export interface MemorySnapshot {
+    /** ISO timestamp when the snapshot was taken. */
+    takenAt: string;
+    /** Adapter-defined snapshot payload. */
+    data: unknown;
+}
+/** A flat fact row returned by the optional {@link MemoryAdapter.listFacts}. */
+export interface MemoryFact {
+    id: string;
+    text: string;
+    source?: string;
+    /** ISO timestamp, when the adapter tracks creation time. */
+    createdAt?: string;
+}
+/**
+ * The single memory adapter contract. All backends — the built-in `inMemory()`
+ * and `redis()` adapters as well as vendor adapters (`hindsight()`, `mem0()`,
+ * `honcho()`) — implement `recall` + `save`. `inspect`/`listFacts` are optional
+ * and exist only for devtools/admin surfaces.
+ */
+export interface MemoryAdapter {
+    /** Stable id used in logs, devtools, and event payloads (e.g. 'in-memory', 'hindsight'). */
+    readonly id: string;
+    /** Optional human-readable label; defaults to {@link MemoryAdapter.id} in logs. */
+    readonly name?: string;
+    /**
+     * Read side — retrieve what's relevant to `query` within `scope`. The ranking
+     * strategy (lexical, semantic, hybrid, vendor-native) is entirely the
+     * adapter's concern.
+     */
+    recall: (scope: MemoryScope, query: string) => Promise<RecallResult>;
+    /**
+     * Write side — persist a completed turn. Extraction (turn → stored facts)
+     * happens HERE, inside the adapter. Returns one receipt per underlying write.
+     */
+    save: (scope: MemoryScope, turn: MemoryTurn) => Promise<Array<SaveReceipt>>;
+    /** Optional — full snapshot for a devtools inspection panel. */
+    inspect?: (scope: MemoryScope) => Promise<MemorySnapshot>;
+    /** Optional — flat fact list for a devtools panel. */
+    listFacts?: (scope: MemoryScope) => Promise<Array<MemoryFact>>;
+}

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@tanstack/ai-memory",
+  "version": "0.0.0",
+  "description": "Pluggable memory adapters for TanStack AI memoryMiddleware",
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/ai.git",
+    "directory": "packages/ai-memory"
+  },
+  "type": "module",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js"
+    },
+    "./in-memory": {
+      "types": "./dist/esm/providers/in-memory/index.d.ts",
+      "import": "./dist/esm/providers/in-memory/index.js"
+    },
+    "./redis": {
+      "types": "./dist/esm/providers/redis/index.d.ts",
+      "import": "./dist/esm/providers/redis/index.js"
+    },
+    "./hindsight": {
+      "types": "./dist/esm/providers/hindsight/index.d.ts",
+      "import": "./dist/esm/providers/hindsight/index.js"
+    },
+    "./mem0": {
+      "types": "./dist/esm/providers/mem0/index.d.ts",
+      "import": "./dist/esm/providers/mem0/index.js"
+    },
+    "./honcho": {
+      "types": "./dist/esm/providers/honcho/index.d.ts",
+      "import": "./dist/esm/providers/honcho/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "skills"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "clean": "premove ./build ./dist",
+    "lint:fix": "oxlint src --type-aware --fix",
+    "test:build": "publint --strict",
+    "test:oxlint": "oxlint src --type-aware",
+    "test:lib": "vitest --passWithNoTests",
+    "test:lib:dev": "pnpm test:lib --watch",
+    "test:types": "tsc"
+  },
+  "keywords": [
+    "ai",
+    "tanstack",
+    "memory",
+    "redis",
+    "rag",
+    "tanstack-intent"
+  ],
+  "dependencies": {
+    "@tanstack/ai-event-client": "workspace:*"
+  },
+  "peerDependencies": {
+    "@honcho-ai/sdk": ">=2.0.0",
+    "@tanstack/ai": "workspace:^",
+    "@vectorize-io/hindsight-client": ">=0.6.0",
+    "ioredis": ">=5.0.0",
+    "redis": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    },
+    "redis": {
+      "optional": true
+    },
+    "@vectorize-io/hindsight-client": {
+      "optional": true
+    },
+    "@honcho-ai/sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@honcho-ai/sdk": "^2.1.1",
+    "@tanstack/ai": "workspace:*",
+    "@vectorize-io/hindsight-client": "^0.6.1",
+    "@vitest/coverage-v8": "4.0.14",
+    "ioredis-mock": "^8.9.0",
+    "redis": "^4.7.0"
+  }
+}