@lojban/semantic-search-mcp 1.0.8 → 1.0.10

package/README.md

@@ -101,6 +101,16 @@ To replace the entire index with new content from several places:
 
 Paths can be anywhere on disk (e.g. different drives or projects); the server reads and indexes all supported text/TSV/CSV files under each directory recursively.
 
+### Memory and batch size
+
+Indexing uses **adaptive batch size** based on free system RAM so the OS doesn’t freeze on low-memory machines. The server reads `os.freemem()`, keeps a reserve (default 400MB), and caps batch size between 32 and 512 lines. You can tune this with env vars:
+
+- **`SEMANTIC_SEARCH_RESERVE_MB`** — MB of RAM to keep free (default `400`).
+- **`SEMANTIC_SEARCH_MIN_BATCH`** — minimum lines per batch (default `32`).
+- **`SEMANTIC_SEARCH_MAX_BATCH`** — maximum lines per batch (default `512`).
+
+Example: `SEMANTIC_SEARCH_RESERVE_MB=800 SEMANTIC_SEARCH_MAX_BATCH=256` to leave more headroom and use smaller batches.
+
 ## Example: Lojban dictionary gaps
 
 1. Put your dictionary TSV (e.g. `jbo-eng.tsv`) in a folder.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lojban/semantic-search-mcp",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Local-first MCP server for semantic search using transformers.js and SQLite",
   "type": "module",
   "scripts": {

package/src/index.ts

@@ -5,6 +5,7 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
+import os from 'node:os';
 import path from 'path';
 import { getEmbedding, getBatchEmbeddings } from './embeddings.js';
 import { createVectorStorage, type SearchResult, type VectorStorage } from './storage.js';
@@ -40,6 +41,26 @@ const indexStatus: IndexStatus = {
 let currentIndexingAbortController: AbortController | null = null;
 let currentJobId = 0;
 
+// Adaptive batch size: reserve RAM so we don't freeze the OS (env overrides in bytes or MB)
+const RESERVE_MB = Number(process.env.SEMANTIC_SEARCH_RESERVE_MB) || 400;
+const RESERVE_BYTES = RESERVE_MB * 1024 * 1024;
+const MIN_BATCH = Number(process.env.SEMANTIC_SEARCH_MIN_BATCH) || 32;
+const MAX_BATCH = Number(process.env.SEMANTIC_SEARCH_MAX_BATCH) || 512;
+
+/** Rough bytes per indexed line in memory: line text + path + embedding (384 floats) + overhead */
+const BYTES_PER_LINE_ESTIMATE = 4000;
+
+/**
+ * Compute batch size from current free system RAM. Keeps reserve free to avoid freezing the OS.
+ */
+function getAdaptiveBatchSize(): number {
+  const free = os.freemem();
+  const available = free > RESERVE_BYTES ? free - RESERVE_BYTES : Math.floor(free / 2);
+  const batch = Math.floor(available / BYTES_PER_LINE_ESTIMATE);
+  const clamped = Math.max(MIN_BATCH, Math.min(MAX_BATCH, batch));
+  return clamped;
+}
+
 /**
  * Request indexing of directories. If another indexing job is running, it is aborted first.
  * Then a new job is started (clears index and rebuilds).
@@ -87,7 +108,6 @@ async function startIndexing(
     console.error(`Scanning ${directories.length} directories (background indexing)...`);
 
     let indexedCount = 0;
-    const BATCH_SIZE = 512;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let currentBatch: any[] = [];
 
@@ -109,24 +129,22 @@ async function startIndexing(
       console.error(`Indexed ${indexedCount} lines...`);
     };
 
-    let processingPromise: Promise<void> | null = null;
+    // Single task queue: only one batch is processed at a time (no pipelining).
+    // We do not read the next batch until the current one is fully done, to avoid memory spikes and OS freezes.
+    let batchSize = getAdaptiveBatchSize();
+    console.error(`Adaptive batch size: ${batchSize} (free RAM: ${Math.round(os.freemem() / 1024 / 1024)}MB, reserve: ${RESERVE_MB}MB)`);
 
     for await (const line of scanDirectories(directories)) {
       if (signal.aborted) break;
 
       currentBatch.push(line);
-      if (currentBatch.length >= BATCH_SIZE) {
-        if (processingPromise) {
-          await processingPromise;
-        }
-        if (signal.aborted) break;
-
+      if (currentBatch.length >= batchSize) {
         const batchToProcess = currentBatch;
         currentBatch = [];
+        batchSize = getAdaptiveBatchSize();
 
-        processingPromise = processBatch(batchToProcess).catch((err) => {
-          console.error('Error in background batch processing:', err);
-        });
+        await processBatch(batchToProcess);
+        if (signal.aborted) break;
       }
     }
 
@@ -135,9 +153,6 @@ async function startIndexing(
       return;
     }
 
-    if (processingPromise) {
-      await processingPromise;
-    }
     if (currentBatch.length > 0) {
       await processBatch(currentBatch);
     }