@oh-my-pi/pi-mnemopi 17.0.7 → 17.0.8

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [17.0.8] - 2026-07-22
+
+### Changed
+
+- Optimized vector operations (exact vector-index search, SHMR similarity clustering, and default-similarity MMR rerank) by migrating hot loops to native batch kernels, resulting in significant performance improvements (up to 1.8x faster top-K search, 2.4x faster pairwise clustering, and 22-36x faster MMR reranking).
+
 ## [17.0.4] - 2026-07-18
 
 ### Fixed

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-mnemopi",
-	"version": "17.0.7",
+	"version": "17.0.8",
 	"description": "Local SQLite memory engine for Oh My Pi agents",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -39,9 +39,10 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "17.0.7",
-		"@oh-my-pi/pi-catalog": "17.0.7",
-		"@oh-my-pi/pi-utils": "17.0.7",
+		"@oh-my-pi/pi-ai": "17.0.8",
+		"@oh-my-pi/pi-catalog": "17.0.8",
+		"@oh-my-pi/pi-natives": "17.0.8",
+		"@oh-my-pi/pi-utils": "17.0.8",
 		"lru-cache": "11.5.2"
 	},
 	"peerDependencies": {

package/src/core/mmr.ts

@@ -1,3 +1,5 @@
+import { mmrRerankIndices } from "@oh-my-pi/pi-natives";
+
 export interface MmrResult {
 	readonly content?: string;
 	readonly score?: number;
@@ -33,6 +35,34 @@ export function mmrRerank<T extends MmrResult>(
 	const first = sortedResults[0];
 	if (first === undefined) return [];
 
+	// Native batch kernel: one N-API crossing selects all indices. Only valid
+	// for the default Jaccard similarity; custom similarity functions stay in
+	// TS. Lone-surrogate contents also stay in TS: N-API converts them to
+	// U+FFFD, which would merge distinct tokens. NaN topK stays in TS so the
+	// pre-native contract (loop guard is false, first result still returned)
+	// is preserved.
+	if (
+		similarityFn === jaccardSimilarity &&
+		!Number.isNaN(limit) &&
+		sortedResults.every(result => (result.content ?? "").isWellFormed())
+	) {
+		// Pre-lowercase with JS semantics so contextual mappings (Final_Sigma:
+		// "ΟΣ" -> "ος") are applied before the context-insensitive native
+		// lowercase, which is idempotent on already-lowercased text.
+		const contents = sortedResults.map(result => (result.content ?? "").toLowerCase());
+		const scores = Float64Array.from(sortedResults, result => result.score ?? 0);
+		// Clamp before the u32 N-API boundary: Infinity or >= 2**32 would
+		// otherwise wrap (ToUint32) and silently return nothing.
+		const nativeLimit = Math.min(limit, sortedResults.length);
+		const picked = mmrRerankIndices(contents, scores, lambdaParam, nativeLimit);
+		const out: T[] = [];
+		for (const index of picked) {
+			const item = sortedResults[index];
+			if (item !== undefined) out.push(item);
+		}
+		return out;
+	}
+
 	const selected: T[] = [first];
 	const remaining = sortedResults.slice(1);
 

package/src/core/shmr.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite";
 import { createHash } from "node:crypto";
+import { cosineSimilarityPairs } from "@oh-my-pi/pi-natives";
 import { logger } from "@oh-my-pi/pi-utils";
 import * as embeddings from "./embeddings";
 import { cosineSimilarity } from "./vector-math";
@@ -166,17 +167,23 @@ export async function clusterBySimilarity(items: readonly ShmrItem[], threshold:
 	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 leftEmbedding = vectors[i];
-		if (leftEmbedding === undefined) continue;
-		for (let j = i + 1; j < items.length; j++) {
-			const rightEmbedding = vectors[j];
-			if (rightEmbedding === undefined) continue;
-			if (cosineSimilarity(leftEmbedding, rightEmbedding) >= threshold) {
-				adjacency[i]?.push(j);
-				adjacency[j]?.push(i);
-			}
-		}
+	// Native batch kernel: one N-API crossing evaluates all O(n^2) pairs.
+	// Vectors are zero-padded to a shared dim, matching the TS `?? 0`
+	// missing-element semantics of cosineSimilarity.
+	let dim = 0;
+	for (const vector of vectors) if (vector.length > dim) dim = vector.length;
+	const flat = new Float64Array(vectors.length * dim);
+	for (let i = 0; i < vectors.length; i++) {
+		const vector = vectors[i];
+		if (vector === undefined) continue;
+		for (let col = 0; col < vector.length; col++) flat[i * dim + col] = vector[col] ?? 0;
+	}
+	const pairs = cosineSimilarityPairs(flat, vectors.length, dim, threshold);
+	for (let p = 0; p < pairs.length; p += 2) {
+		const i = pairs[p] ?? 0;
+		const j = pairs[p + 1] ?? 0;
+		adjacency[i]?.push(j);
+		adjacency[j]?.push(i);
 	}
 	const visited = new Set<number>();
 	const clusters: ShmrItem[][] = [];

package/src/core/vector-index.ts

@@ -1,3 +1,5 @@
+import { vectorIndexTopK } from "@oh-my-pi/pi-natives";
+
 export interface ExactVectorSearchHit<TId> {
 	id: TId;
 	score: number;
@@ -66,19 +68,16 @@ export function searchExactVectorIndex<TId>(
 		queryNormSq += value * value;
 	}
 	if (queryNormSq <= 0) return [];
-	const queryNorm = Math.sqrt(queryNormSq);
-	const queryDimensions = Math.min(query.length, index.dimensions);
+	// Native batch kernel: one N-API crossing scores every row and ranks the
+	// top k with the same stable ordering as the TS sort. TS guards above
+	// (finite query, positive norm, non-empty index) are preserved. Clamp k to
+	// the row count before the u32 boundary: Infinity or >= 2**32 would
+	// otherwise wrap (ToUint32) and return no hits.
+	const topK = vectorIndexTopK(index.matrix, index.dimensions, Float64Array.from(query), Math.min(k, index.count));
 	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 });
+	for (let i = 0; i < topK.indices.length; i += 1) {
+		const row = topK.indices[i] ?? 0;
+		hits.push({ id: index.ids[row] as TId, score: topK.scores[i] ?? 0 });
 	}
-
-	hits.sort((a, b) => b.score - a.score);
-	return hits.slice(0, Math.min(k, hits.length));
+	return hits;
 }