@aeriondyseti/vector-memory-mcp 2.3.0 → 2.4.4

package/server/core/migrations.ts

@@ -1,6 +1,6 @@
 import type { Database } from "bun:sqlite";
-import type { EmbeddingsService } from "./embeddings.service.js";
-import { serializeVector } from "./sqlite-utils.js";
+import type { EmbeddingsService } from "./embeddings.service";
+import { serializeVector } from "./sqlite-utils";
 
 /**
  * Pre-migration step: remove vec0 virtual table entries from sqlite_master
@@ -127,8 +127,25 @@ export async function backfillVectors(
   db: Database,
   embeddings: EmbeddingsService,
 ): Promise<void> {
+  // Quick gap check: if no rows are missing vectors, skip the expensive backfill
+  const hasMemories = db.prepare("SELECT 1 FROM memories LIMIT 1").get();
+  const hasConvos = db.prepare("SELECT 1 FROM conversation_history LIMIT 1").get();
+
+  if (!hasMemories && !hasConvos) return;
+
+  const memoryGap = hasMemories && db.prepare(
+    `SELECT 1 FROM memories m LEFT JOIN memories_vec v ON m.id = v.id
+     WHERE v.id IS NULL OR length(v.vector) = 0 LIMIT 1`,
+  ).get();
+
+  const convoGap = hasConvos && db.prepare(
+    `SELECT 1 FROM conversation_history c LEFT JOIN conversation_history_vec v ON c.id = v.id
+     WHERE v.id IS NULL OR length(v.vector) = 0 LIMIT 1`,
+  ).get();
+
+  if (!memoryGap && !convoGap) return;
+
   // ── Memories ──────────────────────────────────────────────────────
-  // Catch both missing rows (v.id IS NULL) and corrupt 0-byte BLOBs
   const missingMemories = db
     .prepare(
       `SELECT m.id, m.content, json_extract(m.metadata, '$.type') AS type
@@ -151,14 +168,27 @@ export async function backfillVectors(
       new Array(embeddings.dimension).fill(0),
     );
 
-    for (const row of missingMemories) {
-      // Waypoints use a zero vector (not semantically searched)
-      const blob =
-        row.type === "waypoint"
-          ? zeroVector
-          : serializeVector(await embeddings.embed(row.content));
+    // Separate waypoints from content that needs embedding
+    const toEmbed = missingMemories.filter((r) => r.type !== "waypoint");
+    const waypoints = missingMemories.filter((r) => r.type === "waypoint");
 
-      insertVec.run(row.id, blob);
+    // Batch embed all non-waypoint content
+    const vectors = toEmbed.length > 0
+      ? await embeddings.embedBatch(toEmbed.map((r) => r.content))
+      : [];
+
+    db.exec("BEGIN");
+    try {
+      for (const row of waypoints) {
+        insertVec.run(row.id, zeroVector);
+      }
+      for (let i = 0; i < toEmbed.length; i++) {
+        insertVec.run(toEmbed[i].id, serializeVector(vectors[i]));
+      }
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
     }
 
     console.error(
@@ -185,17 +215,27 @@ export async function backfillVectors(
       "INSERT OR REPLACE INTO conversation_history_vec (id, vector) VALUES (?, ?)",
     );
 
-    for (let i = 0; i < missingConvos.length; i++) {
-      const row = missingConvos[i];
-      const vec = serializeVector(await embeddings.embed(row.content));
-      insertConvoVec.run(row.id, vec);
-
-      // Log progress every 100 chunks
-      if ((i + 1) % 100 === 0) {
-        console.error(
-          `[vector-memory-mcp]   ...${i + 1}/${missingConvos.length} conversation chunks`,
-        );
+    // Batch embed in chunks of 32
+    const BATCH_SIZE = 32;
+    db.exec("BEGIN");
+    try {
+      for (let i = 0; i < missingConvos.length; i += BATCH_SIZE) {
+        const batch = missingConvos.slice(i, i + BATCH_SIZE);
+        const vecs = await embeddings.embedBatch(batch.map((r) => r.content));
+        for (let j = 0; j < batch.length; j++) {
+          insertConvoVec.run(batch[j].id, serializeVector(vecs[j]));
+        }
+
+        if ((i + BATCH_SIZE) % 100 < BATCH_SIZE) {
+          console.error(
+            `[vector-memory-mcp]   ...${Math.min(i + BATCH_SIZE, missingConvos.length)}/${missingConvos.length} conversation chunks`,
+          );
+        }
       }
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
     }
 
     console.error(

package/server/core/parsers/claude-code.parser.ts

@@ -1,7 +1,7 @@
 import { readFile, readdir, stat } from "fs/promises";
 import { basename, dirname, join } from "path";
-import type { ParsedMessage, SessionFileInfo } from "../conversation.js";
-import type { SessionLogParser } from "./types.js";
+import type { ParsedMessage, SessionFileInfo } from "../conversation";
+import type { SessionLogParser } from "./types";
 
 // UUID pattern for session IDs
 const UUID_PATTERN =
@@ -45,7 +45,7 @@ export class ClaudeCodeSessionParser implements SessionLogParser {
     const fileName = basename(filePath, ".jsonl");
     const parentDir = basename(dirname(filePath));
     // Check if this is inside a subagents directory
-    const isSubagentFile = filePath.includes("/subagents/");
+    const isSubagentFile = /[/\\]subagents[/\\]/.test(filePath);
 
     // For subagent files, project dir is 3 levels up: <project>/<session>/subagents/<file>
     // For main files, project dir is direct parent

package/server/core/parsers/types.ts

@@ -1,4 +1,4 @@
-import type { ParsedMessage, SessionFileInfo } from "../conversation.js";
+import type { ParsedMessage, SessionFileInfo } from "../conversation";
 
 /** Interface for parsing session log files into structured messages */
 export interface SessionLogParser {

package/server/core/sqlite-utils.ts

@@ -3,6 +3,28 @@ import type { Database } from "bun:sqlite";
 /** RRF constant matching the previous LanceDB reranker default */
 export const RRF_K = 60;
 
+/**
+ * Maximum parameters per SQLite query to stay within SQLITE_MAX_VARIABLE_NUMBER.
+ */
+export const SQLITE_BATCH_SIZE = 100;
+
+/**
+ * Execute a query in batches when the number of parameters exceeds SQLITE_BATCH_SIZE.
+ * Splits the ids array and concatenates results.
+ */
+export function batchedQuery<T>(
+  db: Database,
+  ids: string[],
+  queryFn: (batch: string[]) => T[]
+): T[] {
+  if (ids.length <= SQLITE_BATCH_SIZE) return queryFn(ids);
+  const results: T[] = [];
+  for (let i = 0; i < ids.length; i += SQLITE_BATCH_SIZE) {
+    results.push(...queryFn(ids.slice(i, i + SQLITE_BATCH_SIZE)));
+  }
+  return results;
+}
+
 /**
  * Serialize a number[] embedding to raw float32 bytes for BLOB storage.
  */

package/server/index.ts

@@ -1,15 +1,15 @@
 #!/usr/bin/env bun
 
-import { loadConfig, parseCliArgs } from "./config/index.js";
-import { connectToDatabase } from "./core/connection.js";
-import { backfillVectors } from "./core/migrations.js";
-import { MemoryRepository } from "./core/memory.repository.js";
-import { ConversationRepository } from "./core/conversation.repository.js";
-import { EmbeddingsService } from "./core/embeddings.service.js";
-import { MemoryService } from "./core/memory.service.js";
-import { ConversationHistoryService } from "./core/conversation.service.js";
-import { startServer } from "./transports/mcp/server.js";
-import { startHttpServer } from "./transports/http/server.js";
+import { loadConfig, parseCliArgs } from "./config/index";
+import { connectToDatabase } from "./core/connection";
+import { backfillVectors } from "./core/migrations";
+import { MemoryRepository } from "./core/memory.repository";
+import { ConversationRepository } from "./core/conversation.repository";
+import { EmbeddingsService } from "./core/embeddings.service";
+import { MemoryService } from "./core/memory.service";
+import { ConversationHistoryService } from "./core/conversation.service";
+import { startServer } from "./transports/mcp/server";
+import { startHttpServer } from "./transports/http/server";
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
@@ -25,17 +25,15 @@ async function main(): Promise<void> {
   const overrides = parseCliArgs(args);
   const config = loadConfig(overrides);
 
-  // Initialize database
+  // Initialize database and backfill any missing vectors before services start
   const db = connectToDatabase(config.dbPath);
+  const embeddings = new EmbeddingsService(config.embeddingModel, config.embeddingDimension);
+  await backfillVectors(db, embeddings);
 
   // Initialize layers
   const repository = new MemoryRepository(db);
-  const embeddings = new EmbeddingsService(config.embeddingModel, config.embeddingDimension);
   const memoryService = new MemoryService(repository, embeddings);
 
-  // Backfill any missing vectors (e.g. after vec0-to-BLOB migration)
-  await backfillVectors(db, embeddings);
-
   if (config.pluginMode) {
     console.error("[vector-memory-mcp] Running in plugin mode");
   }

package/server/transports/http/mcp-transport.ts

@@ -21,11 +21,11 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 
-import { tools } from "../mcp/tools.js";
-import { handleToolCall } from "../mcp/handlers.js";
-import { SERVER_INSTRUCTIONS } from "../mcp/server.js";
-import { VERSION } from "../../config/index.js";
-import type { MemoryService } from "../../core/memory.service.js";
+import { tools } from "../mcp/tools";
+import { handleToolCall } from "../mcp/handlers";
+import { SERVER_INSTRUCTIONS } from "../mcp/server";
+import { VERSION } from "../../config/index";
+import type { MemoryService } from "../../core/memory.service";
 
 interface Session {
   server: Server;

package/server/transports/http/server.ts

@@ -3,11 +3,11 @@ import { cors } from "hono/cors";
 import { createServer } from "net";
 import { writeFileSync, mkdirSync, unlinkSync } from "fs";
 import { join } from "path";
-import type { MemoryService } from "../../core/memory.service.js";
-import type { Config } from "../../config/index.js";
-import { isDeleted } from "../../core/memory.js";
-import { createMcpRoutes } from "./mcp-transport.js";
-import type { Memory, SearchIntent } from "../../core/memory.js";
+import type { MemoryService } from "../../core/memory.service";
+import type { Config } from "../../config/index";
+import { isDeleted } from "../../core/memory";
+import { createMcpRoutes } from "./mcp-transport";
+import type { Memory, SearchIntent } from "../../core/memory";
 
 
 /**
@@ -111,10 +111,22 @@ export function createHttpApp(memoryService: MemoryService, config: Config): Hon
         embeddingDimension: config.embeddingDimension,
         historyEnabled: config.conversationHistory.enabled,
         pluginMode: config.pluginMode,
+        embeddingReady: memoryService.getEmbeddings().isReady,
       },
     });
   });
 
+  // Warmup endpoint — triggers ONNX model load if not already cached
+  app.post("/warmup", async (c) => {
+    const embeddings = memoryService.getEmbeddings();
+    if (embeddings.isReady) {
+      return c.json({ status: "already_warm" });
+    }
+    const start = Date.now();
+    await embeddings.warmup();
+    return c.json({ status: "warmed", elapsed: Date.now() - start });
+  });
+
   // Search endpoint
   app.post("/search", async (c) => {
     try {
@@ -127,7 +139,7 @@ export function createHttpApp(memoryService: MemoryService, config: Config): Hon
         return c.json({ error: "Missing or invalid 'query' field" }, 400);
       }
 
-      const results = await memoryService.search(query, intent, limit);
+      const results = await memoryService.search(query, intent, { limit });
 
       return c.json({
         results: results.map((r) => ({

package/server/transports/mcp/handlers.ts

@@ -1,9 +1,9 @@
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import type { MemoryService } from "../../core/memory.service.js";
-import type { ConversationHistoryService } from "../../core/conversation.service.js";
-import type { SearchIntent } from "../../core/memory.js";
-import type { HistoryFilters, SearchResult } from "../../core/conversation.js";
-import { DEBUG } from "../../config/index.js";
+import type { MemoryService } from "../../core/memory.service";
+import type { ConversationHistoryService } from "../../core/conversation.service";
+import type { SearchIntent } from "../../core/memory";
+import type { HistoryFilters, SearchResult } from "../../core/conversation";
+import { DEBUG } from "../../config/index";
 
 /**
  * Safely coerce a tool argument to an array. Handles the case where the MCP
@@ -51,6 +51,14 @@ function parseDate(value: unknown, fieldName: string): Date | undefined {
   return date;
 }
 
+function requireString(args: Record<string, unknown> | undefined, field: string): string {
+  const value = args?.[field];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${field} is required`);
+  }
+  return value;
+}
+
 export async function handleStoreMemories(
   args: Record<string, unknown> | undefined,
   service: MemoryService
@@ -189,7 +197,9 @@ export async function handleSearchMemories(
     return errorResult(errorText(e));
   }
 
-  const results = await service.search(query, intent, limit, includeDeleted, {
+  const results = await service.search(query, intent, {
+    limit,
+    includeDeleted,
     includeHistory,
     historyOnly,
     historyFilters,
@@ -202,19 +212,7 @@ export async function handleSearchMemories(
     };
   }
 
-  const formatted = results.map((r: SearchResult) => {
-    let result = `[${r.source}] ID: ${r.id}\nContent: ${r.content}`;
-    if (r.metadata && Object.keys(r.metadata).length > 0) {
-      result += `\nMetadata: ${JSON.stringify(r.metadata)}`;
-    }
-    if (r.source === "memory" && includeDeleted && r.supersededBy) {
-      result += `\n[DELETED]`;
-    }
-    if (r.source === "conversation_history" && r.sessionId) {
-      result += `\nSession: ${r.sessionId}`;
-    }
-    return result;
-  });
+  const formatted = results.map((r) => formatSearchResult(r, includeDeleted));
 
   return {
     content: [{ type: "text", text: formatted.join("\n\n---\n\n") }],
@@ -241,6 +239,20 @@ function formatMemoryDetail(
   return result;
 }
 
+function formatSearchResult(r: SearchResult, includeDeleted: boolean): string {
+  let result = `[${r.source}] ID: ${r.id}\nContent: ${r.content}`;
+  if (r.metadata && Object.keys(r.metadata).length > 0) {
+    result += `\nMetadata: ${JSON.stringify(r.metadata)}`;
+  }
+  if (r.source === "memory" && includeDeleted && r.supersededBy) {
+    result += `\n[DELETED]`;
+  }
+  if (r.source === "conversation_history" && r.sessionId) {
+    result += `\nSession: ${r.sessionId}`;
+  }
+  return result;
+}
+
 export async function handleGetMemories(
   args: Record<string, unknown> | undefined,
   service: MemoryService
@@ -267,8 +279,11 @@ export async function handleReportMemoryUsefulness(
   args: Record<string, unknown> | undefined,
   service: MemoryService
 ): Promise<CallToolResult> {
-  const memoryId = args?.memory_id as string;
-  const useful = args?.useful as boolean;
+  const memoryId = requireString(args, "memory_id");
+  const useful = args?.useful;
+  if (typeof useful !== "boolean") {
+    return errorResult("useful is required and must be a boolean");
+  }
 
   const memory = await service.vote(memoryId, useful ? 1 : -1);
 
@@ -290,10 +305,19 @@ export async function handleSetWaypoint(
   args: Record<string, unknown> | undefined,
   service: MemoryService
 ): Promise<CallToolResult> {
+  let project: string;
+  let summary: string;
+  try {
+    project = requireString(args, "project");
+    summary = requireString(args, "summary");
+  } catch (e) {
+    return errorResult(errorText(e));
+  }
+
   const memory = await service.setWaypoint({
-    project: args?.project as string,
+    project,
     branch: args?.branch as string | undefined,
-    summary: args?.summary as string,
+    summary,
     completed: (args?.completed as string[] | undefined) ?? [],
     in_progress_blocked: (args?.in_progress_blocked as string[] | undefined) ?? [],
     key_decisions: (args?.key_decisions as string[] | undefined) ?? [],

package/server/transports/mcp/server.ts

@@ -6,12 +6,12 @@ import {
   ListResourcesRequestSchema,
   ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import { resources, readResource } from "./resources.js";
+import { resources, readResource } from "./resources";
 
-import { tools } from "./tools.js";
-import { handleToolCall } from "./handlers.js";
-import type { MemoryService } from "../../core/memory.service.js";
-import { VERSION } from "../../config/index.js";
+import { tools } from "./tools";
+import { handleToolCall } from "./handlers";
+import type { MemoryService } from "../../core/memory.service";
+import { VERSION } from "../../config/index";
 
 export const SERVER_INSTRUCTIONS = `This server is the user's canonical memory system. It provides persistent, semantic vector memory that survives across conversations and sessions.
 

package/scripts/lancedb-extract.ts

@@ -1,181 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Standalone LanceDB data extractor — runs in a child process so that
- * @lancedb/lancedb native bindings never coexist with bun:sqlite's
- * extension loading in the same process.
- *
- * Usage: bun scripts/lancedb-extract.ts <lance-db-path>
- * Output: JSON on stdout — { memories: Row[], conversations: Row[] }
- */
-
-const source = process.argv[2];
-if (!source) {
-  console.error("Usage: bun scripts/lancedb-extract.ts <lance-db-path>");
-  process.exit(1);
-}
-
-// Arrow TimeUnit enum → divisor to convert to milliseconds.
-// 0=SECOND, 1=MILLISECOND, 2=MICROSECOND, 3=NANOSECOND
-// Negative divisor = multiply (seconds → ms needs ×1000).
-const TIME_UNIT_TO_MS_DIVISOR: Record<number, bigint> = {
-  0: -1000n,   // seconds → ms (multiply by 1000)
-  1: 1n,       // ms → no conversion
-  2: 1000n,    // μs → ms
-  3: 1000000n, // ns → ms
-};
-
-function buildTimestampDivisors(schema: any): Map<string, bigint> {
-  const map = new Map<string, bigint>();
-  for (const field of schema.fields) {
-    if (field.type.typeId === 10) {
-      map.set(field.name, TIME_UNIT_TO_MS_DIVISOR[field.type.unit] ?? 1n);
-    }
-  }
-  return map;
-}
-
-function columnValue(batch: any, colName: string, rowIdx: number): unknown {
-  const col = batch.getChild(colName);
-  if (!col) return undefined;
-  try {
-    return col.get(rowIdx);
-  } catch {
-    // Arrow's getter can throw on BigInt timestamps exceeding MAX_SAFE_INTEGER;
-    // fall back to the raw typed array.
-    let offset = rowIdx;
-    for (const data of col.data) {
-      if (offset < data.length) {
-        return (data.values instanceof BigInt64Array || data.values instanceof BigUint64Array)
-          ? data.values[offset]
-          : null;
-      }
-      offset -= data.length;
-    }
-    return null;
-  }
-}
-
-function toEpochMs(value: unknown, divisor: bigint = 1n): number {
-  if (value == null) return Date.now();
-  if (value instanceof Date) return value.getTime();
-  if (typeof value === "bigint") {
-    if (divisor < 0n) return Number(value * -divisor);  // seconds → ms
-    if (divisor === 1n) return Number(value);
-    return Number(value / divisor);
-  }
-  if (typeof value === "number") {
-    if (divisor < 0n) return value * Number(-divisor);
-    if (divisor === 1n) return value;
-    return Math.floor(value / Number(divisor));
-  }
-  return Date.now();
-}
-
-function toFloatArray(vec: unknown): number[] {
-  if (Array.isArray(vec)) return vec;
-  if (vec instanceof Float32Array) return Array.from(vec);
-  if (vec && typeof (vec as any).toArray === "function") {
-    return Array.from((vec as any).toArray());
-  }
-  if (ArrayBuffer.isView(vec)) {
-    const view = vec as DataView;
-    return Array.from(new Float32Array(view.buffer, view.byteOffset, view.byteLength / 4));
-  }
-  return [];
-}
-
-const BATCH_SIZE = 100;
-const lancedb = await import("@lancedb/lancedb");
-const db = await lancedb.connect(source);
-const tableNames = await db.tableNames();
-console.error(`Found tables: ${tableNames.join(", ")}`);
-
-const result: { memories: any[]; conversations: any[] } = {
-  memories: [],
-  conversations: [],
-};
-
-if (tableNames.includes("memories")) {
-  const table = await db.openTable("memories");
-  const total = await table.countRows();
-  console.error(`Reading ${total} memories...`);
-
-  // Paginated scan — query().toArrow() without offset/limit returns
-  // non-deterministic results that can duplicate some rows and skip others.
-  const schemaSample = await table.query().limit(1).toArrow();
-  const tsDivisors = buildTimestampDivisors(schemaSample.schema);
-  const seen = new Map<string, any>();
-
-  for (let offset = 0; offset < total; offset += BATCH_SIZE) {
-    const arrowTable = await table.query().offset(offset).limit(BATCH_SIZE).toArrow();
-    for (const batch of arrowTable.batches) {
-      for (let i = 0; i < batch.numRows; i++) {
-        const id = columnValue(batch, "id", i) as string;
-        const content = columnValue(batch, "content", i) as string;
-        const lastAccessed = columnValue(batch, "last_accessed", i);
-        const accessedMs = lastAccessed != null ? toEpochMs(lastAccessed, tsDivisors.get("last_accessed")) : null;
-        // Deduplicate by ID: prefer most recently accessed, then longest content.
-        const existing = seen.get(id);
-        if (existing) {
-          const existingAccess = existing.last_accessed ?? 0;
-          const newAccess = accessedMs ?? 0;
-          if (newAccess < existingAccess) continue;
-          if (newAccess === existingAccess && content.length <= existing.content.length) continue;
-        }
-        seen.set(id, {
-          id,
-          content,
-          metadata: columnValue(batch, "metadata", i) ?? "{}",
-          vector: toFloatArray(columnValue(batch, "vector", i)),
-          created_at: toEpochMs(columnValue(batch, "created_at", i), tsDivisors.get("created_at")),
-          updated_at: toEpochMs(columnValue(batch, "updated_at", i), tsDivisors.get("updated_at")),
-          last_accessed: accessedMs,
-          superseded_by: columnValue(batch, "superseded_by", i) ?? null,
-          usefulness: columnValue(batch, "usefulness", i) ?? 0,
-          access_count: columnValue(batch, "access_count", i) ?? 0,
-        });
-      }
-    }
-  }
-  result.memories = [...seen.values()];
-  console.error(`  ${result.memories.length} unique memories read (${total} rows scanned)`);
-}
-
-if (tableNames.includes("conversation_history")) {
-  const table = await db.openTable("conversation_history");
-  const total = await table.countRows();
-  console.error(`Reading ${total} conversation chunks...`);
-
-  const schemaSample = await table.query().limit(1).toArrow();
-  const tsDivisors = buildTimestampDivisors(schemaSample.schema);
-  const seen = new Map<string, any>();
-
-  for (let offset = 0; offset < total; offset += BATCH_SIZE) {
-    const arrowTable = await table.query().offset(offset).limit(BATCH_SIZE).toArrow();
-    for (const batch of arrowTable.batches) {
-      for (let i = 0; i < batch.numRows; i++) {
-        const id = columnValue(batch, "id", i) as string;
-        const content = columnValue(batch, "content", i) as string;
-        const existing = seen.get(id);
-        if (existing && existing.content.length >= content.length) continue;
-        seen.set(id, {
-          id,
-          content,
-          metadata: columnValue(batch, "metadata", i) ?? "{}",
-          vector: toFloatArray(columnValue(batch, "vector", i)),
-          created_at: toEpochMs(columnValue(batch, "created_at", i), tsDivisors.get("created_at")),
-          session_id: columnValue(batch, "session_id", i),
-          role: columnValue(batch, "role", i),
-          message_index_start: columnValue(batch, "message_index_start", i) ?? 0,
-          message_index_end: columnValue(batch, "message_index_end", i) ?? 0,
-          project: columnValue(batch, "project", i) ?? "",
-        });
-      }
-    }
-  }
-  result.conversations = [...seen.values()];
-  console.error(`  ${result.conversations.length} unique conversation chunks read (${total} rows scanned)`);
-}
-
-await db.close?.();
-process.stdout.write(JSON.stringify(result));