@prometheus-ai/memory 0.5.4 → 0.5.8

package/src/core/runtime-options.ts

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import type { Api, Model } from "@prometheus-ai/ai";
+import type { Api, ApiKey, Model } from "@prometheus-ai/ai";
 
 export interface MnemopiLlmCompleteOptions {
 	maxTokens?: number;
@@ -31,14 +31,14 @@ export interface MnemopiEmbeddingRuntimeOptions {
 	disabled?: boolean;
 	model?: string;
 	apiUrl?: string;
-	apiKey?: string;
+	apiKey?: ApiKey;
 	provider?: MnemopiEmbeddingProvider | ((texts: readonly string[]) => EmbeddingOutput | Promise<EmbeddingOutput>);
 }
 
 export interface MnemopiLlmRuntimeOptions {
 	enabled?: boolean;
 	baseUrl?: string;
-	apiKey?: string;
+	apiKey?: ApiKey;
 	model?: string | Model<Api>;
 	maxTokens?: number;
 	complete?: MnemopiLlmCompletion;
@@ -51,20 +51,22 @@ export interface MnemopiLlmRuntimeOptions {
 export interface MnemopiRuntimeOptions {
 	embeddings?: false | MnemopiEmbeddingRuntimeOptions;
 	llm?: false | MnemopiLlmRuntimeOptions | Model<Api> | MnemopiLlmCompletion;
+	/** Verbose diagnostics: escalates best-effort failure logs from debug to warn. */
+	debug?: boolean;
 }
 
 export interface ResolvedMnemopiEmbeddingRuntimeOptions {
 	disabled?: boolean;
 	model?: string;
 	apiUrl?: string;
-	apiKey?: string;
+	apiKey?: ApiKey;
 	provider?: MnemopiEmbeddingProvider;
 }
 
 export interface ResolvedMnemopiLlmRuntimeOptions {
 	enabled?: boolean;
 	baseUrl?: string;
-	apiKey?: string;
+	apiKey?: ApiKey;
 	model?: string | Model<Api>;
 	maxTokens?: number;
 	complete?: MnemopiLlmCompletion;
@@ -75,6 +77,7 @@ export interface ResolvedMnemopiLlmRuntimeOptions {
 export interface ResolvedMnemopiRuntimeOptions {
 	embeddings?: ResolvedMnemopiEmbeddingRuntimeOptions;
 	llm?: ResolvedMnemopiLlmRuntimeOptions;
+	debug?: boolean;
 }
 
 const runtimeOptionsStorage = new AsyncLocalStorage<ResolvedMnemopiRuntimeOptions>();
@@ -90,6 +93,11 @@ export function getMnemopiRuntimeOptions(): ResolvedMnemopiRuntimeOptions | unde
 	return runtimeOptionsStorage.getStore();
 }
 
+/** Whether the active runtime scope requested verbose diagnostics (`mnemopi.debug`). */
+export function mnemopiDebugEnabled(): boolean {
+	return runtimeOptionsStorage.getStore()?.debug === true;
+}
+
 export function resolveEmbeddingProvider(
 	provider:
 		| MnemopiEmbeddingProvider

package/src/core/shmr.ts

@@ -1,16 +1,18 @@
 import type { Database } from "bun:sqlite";
 import { createHash } from "node:crypto";
+import { logger } from "@prometheus-ai/utils";
+import * as embeddings from "./embeddings";
 import { cosineSimilarity } from "./vector-math";
 
 export { cosineSimilarity };
 
-export const SHMR_BATCH_SIZE = Number.parseInt(process.env.PROMETHEUS_MEMORY_SHMR_BATCH_SIZE ?? "50", 10);
-export const SHMR_MAX_ITERATIONS = Number.parseInt(process.env.PROMETHEUS_MEMORY_SHMR_MAX_ITERATIONS ?? "3", 10);
+export const SHMR_BATCH_SIZE = Number.parseInt(process.env.MNEMOPROMETHEUS_SHMR_BATCH_SIZE ?? "50", 10);
+export const SHMR_MAX_ITERATIONS = Number.parseInt(process.env.MNEMOPROMETHEUS_SHMR_MAX_ITERATIONS ?? "3", 10);
 export const SHMR_SIMILARITY_THRESHOLD = Number.parseFloat(
-	process.env.PROMETHEUS_MEMORY_SHMR_SIMILARITY_THRESHOLD ?? "0.70",
+	process.env.MNEMOPROMETHEUS_SHMR_SIMILARITY_THRESHOLD ?? "0.70",
 );
-export const SHMR_HARMONY_THRESHOLD = Number.parseFloat(process.env.PROMETHEUS_MEMORY_SHMR_HARMONY_THRESHOLD ?? "0.60");
-export const SHMR_MIN_CLUSTER_SIZE = Number.parseInt(process.env.PROMETHEUS_MEMORY_SHMR_MIN_CLUSTER_SIZE ?? "2", 10);
+export const SHMR_HARMONY_THRESHOLD = Number.parseFloat(process.env.MNEMOPROMETHEUS_SHMR_HARMONY_THRESHOLD ?? "0.60");
+export const SHMR_MIN_CLUSTER_SIZE = Number.parseInt(process.env.MNEMOPROMETHEUS_SHMR_MIN_CLUSTER_SIZE ?? "2", 10);
 export const EMBEDDING_DIM = 384;
 
 export type Vector = Float32Array;
@@ -105,7 +107,7 @@ CREATE INDEX IF NOT EXISTS idx_beliefs_confidence ON harmonic_beliefs(confidence
 export function initSchema(db: Database): void {
 	db.exec(FACTS_SCHEMA_SQL);
 }
-function textForEmbedding(text: string): Vector {
+function hashEmbedding(text: string): Vector {
 	const out = new Float32Array(EMBEDDING_DIM);
 	const words = text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
 	for (const word of words) {
@@ -116,21 +118,62 @@ function textForEmbedding(text: string): Vector {
 	return out;
 }
 
-export function embed(text: string): Vector {
-	return textForEmbedding(text);
+/**
+ * Embed a batch of texts with the configured embedding provider. Falls back to the
+ * deterministic SHA1 bag-of-words hash for the entire batch when no provider is
+ * available or the provider fails, so every returned vector shares one space.
+ */
+export async function embedBatch(texts: readonly string[]): Promise<Vector[]> {
+	if (texts.length === 0) return [];
+	let matrix: embeddings.EmbeddingMatrix | null = null;
+	try {
+		matrix = await embeddings.embed(texts);
+	} catch (error) {
+		logger.debug("mnemopi shmr embedding failed; using hash fallback", { error: String(error) });
+	}
+	if (matrix !== null && matrix.length === texts.length) return matrix;
+	return texts.map(hashEmbedding);
+}
+
+export async function embed(text: string): Promise<Vector> {
+	const [vector] = await embedBatch([text]);
+	return vector ?? hashEmbedding(text);
+}
+
+/**
+ * Resolve one vector per item: caller-provided embeddings are kept, the rest are
+ * batch-embedded in a single provider call (hash fallback when unavailable).
+ */
+async function resolveItemVectors(items: readonly ShmrItem[]): Promise<Vector[]> {
+	const vectors: (Vector | undefined)[] = items.map(item => item.embedding);
+	const missingIndices: number[] = [];
+	const missingTexts: string[] = [];
+	for (let i = 0; i < items.length; i++) {
+		if (vectors[i] !== undefined) continue;
+		missingIndices.push(i);
+		missingTexts.push(items[i]?.object ?? items[i]?.content ?? "");
+	}
+	if (missingIndices.length > 0) {
+		const fresh = await embedBatch(missingTexts);
+		for (let k = 0; k < missingIndices.length; k++) {
+			const index = missingIndices[k];
+			const vector = fresh[k];
+			if (index !== undefined && vector !== undefined) vectors[index] = vector;
+		}
+	}
+	return vectors.map((vector, i) => vector ?? hashEmbedding(items[i]?.object ?? items[i]?.content ?? ""));
 }
 
-export function clusterBySimilarity(items: readonly ShmrItem[], threshold: number): ShmrItem[][] {
+export async function clusterBySimilarity(items: readonly ShmrItem[], threshold: number): Promise<ShmrItem[][]> {
 	if (items.length === 0) return [];
+	const vectors = await resolveItemVectors(items);
 	const adjacency: number[][] = Array.from({ length: items.length }, () => []);
 	for (let i = 0; i < items.length; i++) {
-		const left = items[i];
-		if (left === undefined) continue;
-		const leftEmbedding = left.embedding ?? embed(left.object ?? left.content ?? "");
+		const leftEmbedding = vectors[i];
+		if (leftEmbedding === undefined) continue;
 		for (let j = i + 1; j < items.length; j++) {
-			const right = items[j];
-			if (right === undefined) continue;
-			const rightEmbedding = right.embedding ?? embed(right.object ?? right.content ?? "");
+			const rightEmbedding = vectors[j];
+			if (rightEmbedding === undefined) continue;
 			if (cosineSimilarity(leftEmbedding, rightEmbedding) >= threshold) {
 				adjacency[i]?.push(j);
 				adjacency[j]?.push(i);
@@ -250,16 +293,22 @@ function deterministicBeliefs(cluster: readonly ShmrItem[]): Belief[] {
 	];
 }
 
-export function computeHarmonyScore(beliefs: readonly Belief[], cluster: readonly ShmrItem[]): number {
+export async function computeHarmonyScore(beliefs: readonly Belief[], cluster: readonly ShmrItem[]): Promise<number> {
 	if (beliefs.length === 0 || cluster.length === 0) return 0;
-	const centroid = new Float32Array(EMBEDDING_DIM);
-	for (const item of cluster) {
-		const embedding = item.embedding ?? embed(item.object ?? item.content ?? "");
-		for (let i = 0; i < EMBEDDING_DIM; i++) centroid[i] = (centroid[i] ?? 0) + (embedding[i] ?? 0) / cluster.length;
-	}
+	const itemVectors = await resolveItemVectors(cluster);
+	const beliefVectors = await embedBatch(beliefs.map(belief => `${belief.predicate} ${belief.object}`));
+	let dim = 0;
+	for (const vector of itemVectors) if (vector.length > dim) dim = vector.length;
+	const centroid = new Float32Array(dim);
+	for (const vector of itemVectors)
+		for (let i = 0; i < vector.length; i++) centroid[i] = (centroid[i] ?? 0) + (vector[i] ?? 0) / cluster.length;
 	let total = 0;
-	for (const belief of beliefs)
-		total += cosineSimilarity(embed(`${belief.predicate} ${belief.object}`), centroid) * belief.confidence;
+	for (let k = 0; k < beliefs.length; k++) {
+		const belief = beliefs[k];
+		const vector = beliefVectors[k];
+		if (belief === undefined || vector === undefined) continue;
+		total += cosineSimilarity(vector, centroid) * belief.confidence;
+	}
 	return total / beliefs.length;
 }
 
@@ -305,24 +354,62 @@ function tableExists(db: Database, table: string): boolean {
 	return db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table) !== null;
 }
 
-export function harmonize(
+function parseEmbeddingJson(raw: unknown): Vector | null {
+	if (typeof raw !== "string") return null;
+	try {
+		const parsed = JSON.parse(raw) as unknown;
+		if (!Array.isArray(parsed) || parsed.length === 0) return null;
+		const out = new Float32Array(parsed.length);
+		for (let i = 0; i < parsed.length; i++) {
+			const value = Number(parsed[i]);
+			if (!Number.isFinite(value)) return null;
+			out[i] = value;
+		}
+		return out;
+	} catch {
+		return null;
+	}
+}
+
+/** Precomputed vectors from `memory_embeddings` (written by `scheduleEmbedding()`). */
+function precomputedVectors(db: Database, memoryIds: readonly (string | undefined)[]): Map<string, Vector> {
+	const out = new Map<string, Vector>();
+	const ids = memoryIds.filter((id): id is string => id !== undefined);
+	if (ids.length === 0 || !tableExists(db, "memory_embeddings")) return out;
+	for (let offset = 0; offset < ids.length; offset += 500) {
+		const chunk = ids.slice(offset, offset + 500);
+		const rows = db
+			.query(
+				`SELECT memory_id, embedding_json FROM memory_embeddings WHERE memory_id IN (${chunk.map(() => "?").join(", ")})`,
+			)
+			.all(...chunk) as Array<{ memory_id: string; embedding_json: string | null }>;
+		for (const row of rows) {
+			const vector = parseEmbeddingJson(row.embedding_json);
+			if (vector !== null) out.set(row.memory_id, vector);
+		}
+	}
+	return out;
+}
+
+export async function harmonize(
 	beam: BeamLike,
 	batchSize = SHMR_BATCH_SIZE,
 	maxIterations = SHMR_MAX_ITERATIONS,
 	similarityThreshold = SHMR_SIMILARITY_THRESHOLD,
-): HarmonizeStats {
+): Promise<HarmonizeStats> {
 	const started = performance.now();
 	const db = dbOf(beam);
 	initSchema(db);
-	const candidates: ShmrItem[] = [];
+	const bare: ShmrItem[] = [];
+	const memoryIds: (string | undefined)[] = [];
 	if (tableExists(db, "facts")) {
 		const rows = db
 			.query(
 				"SELECT fact_id, subject, predicate, object, confidence, timestamp FROM facts ORDER BY created_at DESC LIMIT ?",
 			)
 			.all(batchSize) as FactRow[];
-		for (const row of rows)
-			candidates.push({
+		for (const row of rows) {
+			bare.push({
 				fact_id: row.fact_id,
 				subject: row.subject,
 				predicate: row.predicate,
@@ -330,16 +417,17 @@ export function harmonize(
 				confidence: row.confidence ?? 0.5,
 				timestamp: row.timestamp ?? undefined,
 				source: "fact",
-				embedding: embed(row.object),
 			});
+			memoryIds.push(undefined);
+		}
 	}
 	if (tableExists(db, "episodic_memory")) {
 		const rows = db
 			.query("SELECT id, content, importance, created_at FROM episodic_memory ORDER BY created_at DESC LIMIT ?")
 			.all(Math.max(1, Math.floor(batchSize / 2))) as EpisodeRow[];
 		for (const row of rows)
-			if (row.content.length > 10)
-				candidates.push({
+			if (row.content.length > 10) {
+				bare.push({
 					fact_id: `ep_${row.id}`,
 					subject: "memory",
 					predicate: "contains",
@@ -347,10 +435,11 @@ export function harmonize(
 					confidence: row.importance ?? 0.5,
 					timestamp: row.created_at ?? undefined,
 					source: "episodic",
-					embedding: embed(row.content.slice(0, 300)),
 				});
+				memoryIds.push(row.id);
+			}
 	}
-	if (candidates.length < SHMR_MIN_CLUSTER_SIZE)
+	if (bare.length < SHMR_MIN_CLUSTER_SIZE)
 		return {
 			clusters_found: 0,
 			beliefs_generated: 0,
@@ -359,7 +448,15 @@ export function harmonize(
 			duration_ms: Math.floor(performance.now() - started),
 			status: "insufficient_candidates",
 		};
-	const clusters = clusterBySimilarity(candidates, similarityThreshold).filter(
+	const precomputed = precomputedVectors(db, memoryIds);
+	const seeded: ShmrItem[] = bare.map((item, i) => {
+		const memoryId = memoryIds[i];
+		const vector = memoryId !== undefined ? precomputed.get(memoryId) : undefined;
+		return vector === undefined ? item : { ...item, embedding: vector };
+	});
+	const itemVectors = await resolveItemVectors(seeded);
+	const candidates: ShmrItem[] = seeded.map((item, i) => ({ ...item, embedding: itemVectors[i] }));
+	const clusters = (await clusterBySimilarity(candidates, similarityThreshold)).filter(
 		cluster => cluster.length >= SHMR_MIN_CLUSTER_SIZE,
 	);
 	let totalBeliefs = 0;
@@ -371,7 +468,10 @@ export function harmonize(
 		const clusterId = `shmr_${Date.now()}_${clusterIndex}`;
 		for (let iteration = 0; iteration < maxIterations; iteration++) {
 			const beliefs = deterministicBeliefs(cluster);
-			const score = Math.max(computeHarmonyScore(beliefs, cluster), beliefs.length > 0 ? SHMR_HARMONY_THRESHOLD : 0);
+			const score = Math.max(
+				await computeHarmonyScore(beliefs, cluster),
+				beliefs.length > 0 ? SHMR_HARMONY_THRESHOLD : 0,
+			);
 			scores.push(score);
 			if (score >= SHMR_HARMONY_THRESHOLD) {
 				applyBeliefs(db, beliefs, cluster, clusterId);
@@ -406,19 +506,21 @@ export function harmonize(
 	};
 }
 
-export function recallBeliefs(beam: BeamLike, query: string, topK = 10): Array<Record<string, unknown>> {
+export async function recallBeliefs(beam: BeamLike, query: string, topK = 10): Promise<Array<Record<string, unknown>>> {
 	const db = dbOf(beam);
 	initSchema(db);
-	const queryEmbedding = embed(query);
 	const rows = db
 		.query(
 			"SELECT belief_id, subject, predicate, object, confidence, provenance, created_at FROM harmonic_beliefs ORDER BY confidence DESC LIMIT ?",
 		)
 		.all(topK * 2) as BeliefRow[];
+	const vectors = await embedBatch([query, ...rows.map(row => row.object)]);
+	const queryEmbedding = vectors[0] ?? hashEmbedding(query);
 	return rows
-		.map(row => ({
+		.map((row, index) => ({
 			row,
-			score: cosineSimilarity(queryEmbedding, embed(row.object)) * (row.confidence ?? 0.5),
+			score:
+				cosineSimilarity(queryEmbedding, vectors[index + 1] ?? hashEmbedding(row.object)) * (row.confidence ?? 0.5),
 		}))
 		.sort((a, b) => b.score - a.score)
 		.slice(0, topK)

package/src/core/streaming.ts

@@ -290,7 +290,7 @@ function assertDeltaTable(table: unknown): asserts table is DeltaTable {
 function checkpointRoot(host: MemoryHost): string {
 	const path = host.dbPath ?? host.db_path;
 	return path === undefined || path === ":memory:"
-		? join(process.cwd(), ".prometheus-memory-sync")
+		? join(process.cwd(), ".mnemopi-sync")
 		: join(path, "..", "sync_checkpoints");
 }
 

package/src/core/triples.ts

@@ -74,12 +74,12 @@ function homeDir(env: ProcessEnv = process.env): string {
 }
 
 export function legacyDataDir(env: ProcessEnv = process.env): string {
-	return join(homeDir(env), ".prometheus", "memory", "data");
+	return join(homeDir(env), ".hermes", "mnemopi", "data");
 }
 
 export function defaultDataDir(env: ProcessEnv = process.env): string {
-	return env.PROMETHEUS_MEMORY_DATA_DIR && env.PROMETHEUS_MEMORY_DATA_DIR.length > 0
-		? env.PROMETHEUS_MEMORY_DATA_DIR
+	return env.MNEMOPROMETHEUS_DATA_DIR && env.MNEMOPROMETHEUS_DATA_DIR.length > 0
+		? env.MNEMOPROMETHEUS_DATA_DIR
 		: legacyDataDir(env);
 }
 

package/src/core/vector-index.ts

@@ -0,0 +1,84 @@
+export interface ExactVectorSearchHit<TId> {
+	id: TId;
+	score: number;
+}
+
+export interface ExactVectorIndex<TId> {
+	readonly ids: readonly TId[];
+	readonly matrix: Float32Array;
+	readonly dimensions: number;
+	readonly count: number;
+}
+
+export interface VectorIndexRow<TId> {
+	id: TId;
+	vector: readonly number[] | null | undefined;
+}
+
+export function buildExactVectorIndex<TId>(rows: readonly VectorIndexRow<TId>[]): ExactVectorIndex<TId> {
+	const valid: Array<{ id: TId; vector: readonly number[]; norm: number }> = [];
+	let dimensions = 0;
+	for (const row of rows) {
+		const vector = row.vector;
+		if (!vector || vector.length === 0) continue;
+		let normSq = 0;
+		for (let i = 0; i < vector.length; i += 1) {
+			const value = vector[i] ?? 0;
+			if (!Number.isFinite(value)) {
+				normSq = 0;
+				break;
+			}
+			normSq += value * value;
+		}
+		if (normSq <= 0) continue;
+		valid.push({ id: row.id, vector, norm: Math.sqrt(normSq) });
+		if (vector.length > dimensions) dimensions = vector.length;
+	}
+
+	// Float32Array keeps a compact contiguous matrix that matches the shape we'd
+	// feed into future ANN/quantized backends. Exact cosine ranking remains sound
+	// here because we store normalized vectors and only compare normalized dots.
+	const matrix = new Float32Array(valid.length * dimensions);
+	const ids: TId[] = [];
+	for (let row = 0; row < valid.length; row += 1) {
+		const item = valid[row];
+		ids.push(item.id);
+		const offset = row * dimensions;
+		for (let col = 0; col < item.vector.length; col += 1) {
+			matrix[offset + col] = (item.vector[col] ?? 0) / item.norm;
+		}
+	}
+
+	return { ids, matrix, dimensions, count: ids.length };
+}
+
+export function searchExactVectorIndex<TId>(
+	index: ExactVectorIndex<TId>,
+	query: readonly number[],
+	limit: number,
+): ExactVectorSearchHit<TId>[] {
+	const k = Math.max(0, Math.trunc(limit));
+	if (k === 0 || index.count === 0 || index.dimensions === 0 || query.length === 0) return [];
+
+	let queryNormSq = 0;
+	for (const value of query) {
+		if (!Number.isFinite(value)) return [];
+		queryNormSq += value * value;
+	}
+	if (queryNormSq <= 0) return [];
+	const queryNorm = Math.sqrt(queryNormSq);
+	const queryDimensions = Math.min(query.length, index.dimensions);
+	const hits: ExactVectorSearchHit<TId>[] = [];
+
+	for (let row = 0; row < index.count; row += 1) {
+		const offset = row * index.dimensions;
+		let score = 0;
+		for (let col = 0; col < queryDimensions; col += 1) {
+			score += index.matrix[offset + col] * ((query[col] ?? 0) / queryNorm);
+		}
+		hits.push({ id: index.ids[row] as TId, score });
+	}
+
+	hits.sort((a, b) => b.score - a.score);
+	return hits.slice(0, Math.min(k, hits.length));
+}

package/src/diagnose.ts

@@ -101,8 +101,8 @@ export function inspectDatabase(options: DiagnosticOptions = {}): DiagnosticSumm
 
 	log("env", "bun_version", Bun.version);
 	log("env", "platform", `${process.platform}-${process.arch}`);
-	log("env", "PROMETHEUS_MEMORY_DATA_DIR", safeEnv("PROMETHEUS_MEMORY_DATA_DIR"));
-	log("env", "PROMETHEUS_MEMORY_VEC_TYPE", safeEnv("PROMETHEUS_MEMORY_VEC_TYPE"));
+	log("env", "MNEMOPROMETHEUS_DATA_DIR", safeEnv("MNEMOPROMETHEUS_DATA_DIR"));
+	log("env", "MNEMOPROMETHEUS_VEC_TYPE", safeEnv("MNEMOPROMETHEUS_VEC_TYPE"));
 	log("db", "db_path", "OK", path);
 	log("db", "data_dir", "OK", options.dataDir ?? configuredDataDir());
 	log("db", "data_dir_parent", existsSync(dirname(path)) ? "OK" : "MISSING", dirname(path));

package/src/dr/recovery.ts

@@ -111,7 +111,7 @@ function hasErrorCode(error: unknown, code: string): boolean {
 function writeBackupFile(destinationDir: string, timestamp: string, bytes: Uint8Array): string {
 	for (let attempt = 0; attempt < 64; attempt += 1) {
 		const suffix = attempt === 0 ? "" : `_${nextUniqueToken()}`;
-		const backupPath = join(destinationDir, `prometheus_memory_backup_${timestamp}${suffix}.db.gz`);
+		const backupPath = join(destinationDir, `mnemopi_backup_${timestamp}${suffix}.db.gz`);
 		try {
 			writeFileSync(backupPath, bytes, { flag: "wx" });
 			return backupPath;
@@ -128,7 +128,7 @@ function restoreTempPath(targetPath: string): string {
 }
 
 function defaultBackupDir(env: Env = process.env): string {
-	const explicit = env.PROMETHEUS_MEMORY_BACKUP_DIR;
+	const explicit = env.MNEMOPROMETHEUS_BACKUP_DIR;
 	if (explicit !== undefined && explicit.length > 0) return explicit;
 	const dir = configuredDataDir(env);
 	return join(dirname(dir), "backups");
@@ -291,7 +291,7 @@ export function emergencyRestore(backupDir?: string | null, dbPath?: string | nu
 	const targetPath = dbPath ?? paths.dbPath;
 	const backups = existsSync(dir)
 		? readdirSync(dir)
-				.filter(name => /^prometheus_memory_backup_.*\.db\.gz$/.test(name))
+				.filter(name => /^mnemopi_backup_.*\.db\.gz$/.test(name))
 				.sort()
 				.reverse()
 				.map(name => join(dir, name))
@@ -331,7 +331,7 @@ export function listBackups(backupDir?: string | null): BackupInfo[] {
 	if (!existsSync(dir)) return [];
 
 	return readdirSync(dir)
-		.filter(name => /^prometheus_memory_backup_.*\.db\.gz$/.test(name))
+		.filter(name => /^mnemopi_backup_.*\.db\.gz$/.test(name))
 		.sort()
 		.reverse()
 		.map(name => {
@@ -352,7 +352,7 @@ export function rotateBackups(backupDir?: string | null, keep = 10): RotateBacku
 	const dir = backupDir ?? getDefaultPaths().backupDir;
 	const backups = existsSync(dir)
 		? readdirSync(dir)
-				.filter(name => /^prometheus_memory_backup_.*\.db\.gz$/.test(name))
+				.filter(name => /^mnemopi_backup_.*\.db\.gz$/.test(name))
 				.sort()
 				.map(name => join(dir, name))
 		: [];

package/src/index.ts

@@ -1,3 +1,4 @@
+export { configureRecallFeatures, type RecallFeatureFlags } from "./config";
 export * from "./core/beam/index";
 export * from "./core/embeddings";
 export * from "./core/llm-backends";
@@ -12,7 +13,6 @@ export {
 	getDefaultInstance,
 	getStats,
 	Mnemopi,
-	Mnemopi as PrometheusMemory,
 	query,
 	recall,
 	recallEnhanced,

package/src/mcp-server.ts

@@ -72,7 +72,7 @@ export async function handleJsonRpc(request: JsonRpcRequest): Promise<JsonRpcRes
 	if (method === "initialize") {
 		return ok(id, {
 			protocolVersion: "2024-11-05",
-			serverInfo: { name: "prometheus-memory", version: "3.1.2" },
+			serverInfo: { name: "mnemopi", version: "3.1.2" },
 			capabilities: { tools: {} },
 		});
 	}
@@ -130,7 +130,7 @@ export function runMcpServer(
 	transport = "stdio",
 	options: { port?: number; bank?: string; host?: string } = {},
 ): Promise<void> {
-	if (options.bank !== undefined && options.bank.length > 0) process.env.PROMETHEUS_MEMORY_MCP_BANK = options.bank;
+	if (options.bank !== undefined && options.bank.length > 0) process.env.MNEMOPROMETHEUS_MCP_BANK = options.bank;
 	if (transport !== "stdio") throw new Error("Only stdio transport is implemented in the TypeScript port");
 	return runStdio();
 }