local-ai-memory-bridge 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Radwan Al-Maswari - Software Developer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,104 @@
-# Temporary Holding Version
+# 🧠 Local AI Memory Bridge
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Persistent, encrypted, fully offline long-term memory for AI agents** (Claude Code, Cursor, and any MCP client).
+Your memories never leave your machine.
+
+> ⚠️ **Status: alpha (v0.1).** Save, search, redaction and the MCP server are tested. `compact` is implemented but has had limited testing.
+
+## Why
+
+- 🔒 **Whole-database encryption** (SQLCipher) plus AES-256-GCM on every memory text
+- 🔑 **Master key in your OS keychain** (falls back to a `chmod 600` key file where no keychain exists, e.g. Codespaces or Docker)
+- 🧹 **Secrets redacted before anything is embedded or stored** (API keys, tokens, passwords, JWTs, private keys, credit cards, emails)
+- 🌍 **Multilingual semantic search** (`multilingual-e5-small`, 100+ languages including Arabic), running locally via ONNX
+- 🔌 **Native MCP server** over stdio
+
+## Architecture
+
+```mermaid
+flowchart LR
+  A[AI Agent<br/>Claude Code / Cursor] -- MCP stdio --> B[MCP Server]
+  B --> C[PII Redaction<br/>regex + entropy]
+  C --> D[Local Embeddings<br/>e5-small ONNX]
+  D --> E[(SQLCipher DB<br/>sqlite-vec + AES-GCM text)]
+  K[OS Keychain] -. master key .-> E
+  E --> F[Compaction<br/>cluster + dedupe]
+```
+
+## Quick Start
+
+```bash
+git clone https://github.com/radwanalmsora/local-ai-memory-bridge
+cd local-ai-memory-bridge
+npm install
+npx tsx src/cli.ts add "I prefer TypeScript for new projects"
+npx tsx src/cli.ts search "what language do I prefer?"
+npx tsx src/cli.ts setup
+```
+
+The first run downloads the embedding model (about 100-150 MB) to `~/.memory-bridge/models`.
+
+### Connect to Claude Code
+
+```bash
+claude mcp add memory-bridge -- npx -y tsx /path/to/local-ai-memory-bridge/src/cli.ts serve
+```
+
+### Connect to Cursor (`mcp.json`)
+
+```json
+{
+  "mcpServers": {
+    "memory-bridge": {
+      "command": "npx",
+      "args": ["-y", "tsx", "/path/to/local-ai-memory-bridge/src/cli.ts", "serve"]
+    }
+  }
+}
+```
+
+## CLI
+
+| Command | Description |
+|---|---|
+| `serve` | Run the MCP server (stdio) |
+| `add <text> [-p project]` | Save a memory (redacted automatically) |
+| `search <query> [-n 5] [-p project]` | Semantic search |
+| `forget <id>` | Delete a memory |
+| `compact [-d 30] [-t 0.93]` | Merge near-duplicate memories older than N days |
+| `stats` | Show counts and DB path |
+| `setup` | Print MCP config snippets |
+
+## MCP Tools
+
+| Tool | Input | Purpose |
+|---|---|---|
+| `memory_save` | `text`, `project?` | Store a durable fact or decision |
+| `memory_search` | `query`, `limit?`, `project?` | Semantic recall |
+| `memory_forget` | `id` | Delete a memory |
+
+## Configuration
+
+| Env var | Default | Meaning |
+|---|---|---|
+| `MEMORY_BRIDGE_HOME` | `~/.memory-bridge` | Data directory |
+| `MEMORY_BRIDGE_KEY` | *(unset)* | 64-char hex master key override |
+| `MEMORY_BRIDGE_MODEL` | `Xenova/multilingual-e5-small` | Embedding model |
+| `MEMORY_BRIDGE_MARGIN` | `0.04` | Relevance cut-off relative to the best hit |
+
+## Security model and limits
+
+- Redaction is best-effort (patterns plus entropy). It will miss some secrets, so don't rely on it as your only control.
+- If the master key is lost, the data cannot be recovered.
+- This protects data at rest on your machine, not against malware running as your user.
+
+## Roadmap
+
+- [ ] One-command install via npm (`npx`)
+- [ ] Optional NER-based PII detection
+- [ ] Optional local-LLM summarization (Ollama)
+- [ ] Tests and CI
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { resolve } from "node:path";
+import { MemoryStore } from "./store.js";
+import { serve } from "./mcp.js";
+const program = new Command("memory-bridge")
+    .description("Local, encrypted, offline long-term memory for AI agents").version("0.1.0");
+program.command("serve").description("Run the MCP server (stdio)").action(serve);
+program.command("add <text>").option("-p, --project <name>", "project", "default")
+    .action(async (text, o) => {
+    const r = await (await MemoryStore.open()).add(text, o.project);
+    console.log(`saved #${r.id}`, r.redactions.length ? `(redacted: ${r.redactions.join(", ")})` : "");
+});
+program.command("search <query>").option("-n, --limit <n>", "results", "5").option("-p, --project <name>")
+    .action(async (q, o) => {
+    for (const h of await (await MemoryStore.open()).search(q, +o.limit, o.project))
+        console.log(`#${h.id} [${h.score}] ${h.text}\n`);
+});
+program.command("forget <id>").action(async (id) => console.log((await MemoryStore.open()).forget(+id) ? "deleted" : "not found"));
+program.command("stats").action(async () => console.log((await MemoryStore.open()).stats()));
+program.command("compact").option("-d, --days <n>", "older than N days", "30").option("-t, --threshold <x>", "similarity", "0.93")
+    .action(async (o) => console.log(await (await MemoryStore.open()).compact(+o.days, +o.threshold)));
+program.command("setup").description("Print MCP config for Claude Code / Cursor").action(() => {
+    const script = resolve(process.argv[1]);
+    const cmd = script.endsWith(".ts") ? ["npx", "-y", "tsx", script, "serve"] : ["node", script, "serve"];
+    console.log("Claude Code:\n  claude mcp add memory-bridge -- " + cmd.join(" "));
+    console.log("\nCursor / mcp.json:\n" + JSON.stringify({ mcpServers: { "memory-bridge": { command: cmd[0], args: cmd.slice(1) } } }, null, 2));
+});
+await program.parseAsync();
+if (process.argv[2] !== "serve")
+    process.exit(0);

package/dist/compress.js

@@ -0,0 +1,36 @@
+/** Local compaction (no LLM): cluster near-duplicates, merge, dedupe lines. */
+export const cosine = (a, b) => {
+    let s = 0;
+    for (let i = 0; i < a.length; i++)
+        s += a[i] * b[i];
+    return s; // vectors are normalized
+};
+export function cluster(vecs, threshold) {
+    const used = new Set(), groups = [];
+    for (let i = 0; i < vecs.length; i++) {
+        if (used.has(i))
+            continue;
+        const g = [i];
+        used.add(i);
+        for (let j = i + 1; j < vecs.length; j++)
+            if (!used.has(j) && cosine(vecs[i], vecs[j]) >= threshold) {
+                g.push(j);
+                used.add(j);
+            }
+        groups.push(g);
+    }
+    return groups;
+}
+export function mergeTexts(texts, maxChars = 1500) {
+    const seen = new Set(), lines = [];
+    for (const t of texts)
+        for (const l of t.split("\n")) {
+            const k = l.trim().toLowerCase();
+            if (k && !seen.has(k)) {
+                seen.add(k);
+                lines.push(l.trim());
+            }
+        }
+    const out = lines.join("\n");
+    return out.length > maxChars ? out.slice(0, maxChars) + "…" : out;
+}

package/dist/crypto.js

@@ -0,0 +1,15 @@
+import { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from "node:crypto";
+/** Derive independent subkeys (db / field) from the master key. */
+export const subkey = (master, label) => Buffer.from(hkdfSync("sha256", master, Buffer.alloc(0), label, 32));
+/** AES-256-GCM. Layout: iv(12) | tag(16) | ciphertext */
+export function seal(key, text) {
+    const iv = randomBytes(12);
+    const c = createCipheriv("aes-256-gcm", key, iv);
+    const ct = Buffer.concat([c.update(text, "utf8"), c.final()]);
+    return Buffer.concat([iv, c.getAuthTag(), ct]);
+}
+export function open(key, blob) {
+    const d = createDecipheriv("aes-256-gcm", key, blob.subarray(0, 12));
+    d.setAuthTag(blob.subarray(12, 28));
+    return Buffer.concat([d.update(blob.subarray(28)), d.final()]).toString("utf8");
+}

package/dist/embeddings.js

@@ -0,0 +1,17 @@
+import { env, pipeline } from "@huggingface/transformers";
+import { join } from "node:path";
+import { HOME } from "./keystore.js";
+/** Local multilingual embeddings (ONNX, int8). Downloaded once, cached locally. */
+env.cacheDir = join(HOME, "models");
+const MODEL = process.env.MEMORY_BRIDGE_MODEL ?? "Xenova/multilingual-e5-small";
+export const DIM = 384;
+let extractor = null;
+const load = () => (extractor ??= pipeline("feature-extraction", MODEL, { dtype: "q8" }));
+async function embed(text) {
+    const ex = await load();
+    const out = await ex(text, { pooling: "mean", normalize: true });
+    return Float32Array.from(out.data);
+}
+// E5 models REQUIRE these prefixes for good quality
+export const embedPassage = (t) => embed("passage: " + t);
+export const embedQuery = (t) => embed("query: " + t);

package/dist/keystore.js

@@ -0,0 +1,34 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const HOME = process.env.MEMORY_BRIDGE_HOME ?? join(homedir(), ".memory-bridge");
+/** Master key: env override -> OS keychain -> 0600 file fallback. */
+export async function getMasterKey() {
+    if (process.env.MEMORY_BRIDGE_KEY)
+        return Buffer.from(process.env.MEMORY_BRIDGE_KEY, "hex");
+    try {
+        const { Entry } = await import("@napi-rs/keyring");
+        const entry = new Entry("local-ai-memory-bridge", "master-key");
+        let hex = null;
+        try {
+            hex = entry.getPassword();
+        }
+        catch { }
+        if (!hex) {
+            hex = randomBytes(32).toString("hex");
+            entry.setPassword(hex);
+        }
+        console.error("[memory-bridge] key source: OS keychain");
+        return Buffer.from(hex, "hex");
+    }
+    catch {
+        // stderr only: stdout is reserved for the MCP protocol
+        console.error("[memory-bridge] OS keychain unavailable, using key file (chmod 600)");
+        mkdirSync(HOME, { recursive: true, mode: 0o700 });
+        const f = join(HOME, "master.key");
+        if (!existsSync(f))
+            writeFileSync(f, randomBytes(32).toString("hex"), { mode: 0o600 });
+        return Buffer.from(readFileSync(f, "utf8").trim(), "hex");
+    }
+}

package/dist/mcp.js

@@ -0,0 +1,20 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { MemoryStore } from "./store.js";
+/** MCP server over stdio. NEVER write to stdout here (it carries the protocol). */
+export async function serve() {
+    const store = await MemoryStore.open();
+    const server = new McpServer({ name: "local-ai-memory-bridge", version: "0.1.0" });
+    const reply = (s) => ({ content: [{ type: "text", text: s }] });
+    server.tool("memory_save", "Save a durable fact, decision or preference to long-term local memory. Secrets are auto-redacted.", { text: z.string().min(1), project: z.string().optional() }, async ({ text, project }) => {
+        const r = await store.add(text, project);
+        return reply(`Saved #${r.id}` + (r.redactions.length ? ` (redacted: ${r.redactions.join(", ")})` : ""));
+    });
+    server.tool("memory_search", "Semantic search over long-term memory (multilingual, incl. Arabic). Call at the start of a task.", { query: z.string().min(1), limit: z.number().int().min(1).max(20).optional(), project: z.string().optional() }, async ({ query, limit, project }) => {
+        const hits = await store.search(query, limit ?? 5, project);
+        return reply(hits.length ? hits.map((h) => `#${h.id} [${h.score}] ${h.text}`).join("\n---\n") : "No memories found.");
+    });
+    server.tool("memory_forget", "Delete a memory by id.", { id: z.number().int() }, async ({ id }) => reply(store.forget(id) ? `Deleted #${id}` : `#${id} not found`));
+    await server.connect(new StdioServerTransport());
+}

package/dist/redact.js

@@ -0,0 +1,54 @@
+/** PII / secret redaction: known patterns + Shannon-entropy fallback. */
+// [label, regex, keepPrefix]  keepPrefix=true keeps capture group 1
+const RULES = [
+    ["PRIVATE_KEY", /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, false],
+    ["AWS_KEY", /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, false],
+    ["GITHUB_TOKEN", /\b(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{20,}\b/g, false],
+    ["ANTHROPIC_KEY", /\bsk-ant-[A-Za-z0-9_-]{20,}/g, false],
+    ["API_KEY", /\bsk-[A-Za-z0-9_-]{20,}/g, false],
+    ["SLACK_TOKEN", /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, false],
+    ["GOOGLE_KEY", /\bAIza[0-9A-Za-z_-]{35}\b/g, false],
+    ["JWT", /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, false],
+    ["URL_PASSWORD", /([a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:)[^\s@/]+(?=@)/gi, true],
+    ["SECRET_ASSIGN", /(\b(?:password|passwd|pwd|secret|token|api[_-]?key|apikey)\s*[:=]\s*)(?:"[^"]+"|'[^']+'|[^\s"',;]{4,})/gi, true],
+    ["EMAIL", /\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b/g, false],
+];
+const entropy = (s) => {
+    const f = new Map();
+    for (const ch of s)
+        f.set(ch, (f.get(ch) ?? 0) + 1);
+    return -[...f.values()].reduce((a, n) => a + (n / s.length) * Math.log2(n / s.length), 0);
+};
+const luhn = (d) => {
+    let sum = 0, alt = false;
+    for (let i = d.length - 1; i >= 0; i--) {
+        let n = +d[i];
+        if (alt && (n *= 2) > 9)
+            n -= 9;
+        sum += n;
+        alt = !alt;
+    }
+    return sum % 10 === 0;
+};
+export function redact(input) {
+    let text = input;
+    const findings = [];
+    for (const [label, re, keep] of RULES)
+        text = text.replace(re, (...m) => { findings.push(label); return (keep ? m[1] : "") + `[REDACTED:${label}]`; });
+    text = text.replace(/\b(?:\d[ -]?){13,19}\b/g, (m) => {
+        const d = m.replace(/\D/g, "");
+        if (d.length >= 13 && luhn(d)) {
+            findings.push("CREDIT_CARD");
+            return "[REDACTED:CREDIT_CARD]";
+        }
+        return m;
+    });
+    text = text.replace(/[A-Za-z0-9_+=-]{24,}/g, (m) => {
+        if (/[A-Za-z]/.test(m) && /\d/.test(m) && entropy(m) > 4.0) {
+            findings.push("HIGH_ENTROPY");
+            return "[REDACTED:HIGH_ENTROPY]";
+        }
+        return m;
+    });
+    return { text, findings };
+}

package/dist/store.js

@@ -0,0 +1,122 @@
+import Database from "better-sqlite3-multiple-ciphers";
+import * as sqliteVec from "sqlite-vec";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getMasterKey, HOME } from "./keystore.js";
+import { open, seal, subkey } from "./crypto.js";
+import { redact } from "./redact.js";
+import { DIM, embedPassage, embedQuery } from "./embeddings.js";
+import { cluster, mergeTexts } from "./compress.js";
+const blob = (v) => Buffer.from(v.buffer, v.byteOffset, v.byteLength);
+const toF32 = (b) => new Float32Array(Uint8Array.from(b).buffer);
+export class MemoryStore {
+    db;
+    fieldKey;
+    constructor(db, fieldKey) {
+        this.db = db;
+        this.fieldKey = fieldKey;
+    }
+    static async open() {
+        mkdirSync(HOME, { recursive: true, mode: 0o700 });
+        const master = await getMasterKey();
+        const db = new Database(join(HOME, "memory.db"));
+        db.pragma("cipher='sqlcipher'"); // whole-DB encryption
+        try {
+            db.pragma(`key="x'${subkey(master, "db").toString("hex")}'"`);
+        }
+        catch (e) {
+            if (e.code === "SQLITE_NOTADB")
+                throw new Error("Cannot decrypt memory.db: the master key does not match. Restore your key (MEMORY_BRIDGE_KEY) or delete ~/.memory-bridge/memory.db to start fresh.");
+            throw e;
+        }
+        sqliteVec.load(db);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS memories(
+        id INTEGER PRIMARY KEY, project TEXT NOT NULL DEFAULT 'default',
+        content BLOB NOT NULL, created_at INTEGER NOT NULL,
+        accessed_at INTEGER NOT NULL, hits INTEGER NOT NULL DEFAULT 0,
+        compacted INTEGER NOT NULL DEFAULT 0);
+      CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(embedding float[${DIM}]);`);
+        return new MemoryStore(db, subkey(master, "field"));
+    }
+    put(project, text, vec, compacted = 0, createdAt = Date.now()) {
+        const now = Date.now();
+        const r = this.db.prepare("INSERT INTO memories(project,content,created_at,accessed_at,compacted) VALUES (?,?,?,?,?)").run(project, seal(this.fieldKey, text), createdAt, now, compacted);
+        this.db.prepare("INSERT INTO vec_memories(rowid, embedding) VALUES (?, ?)")
+            .run(BigInt(r.lastInsertRowid), blob(vec));
+        return Number(r.lastInsertRowid);
+    }
+    async add(raw, project = "default") {
+        const { text, findings } = redact(raw); // redact BEFORE embedding/storing
+        const vec = await embedPassage(text);
+        const id = this.db.transaction(() => this.put(project, text, vec))();
+        return { id: id, redactions: findings };
+    }
+    async search(query, limit = 5, project) {
+        const q = await embedQuery(query);
+        const rows = this.db.prepare("SELECT rowid, distance FROM vec_memories WHERE embedding MATCH ? AND k = ?").all(blob(q), limit * 4);
+        const get = this.db.prepare("SELECT id,project,content,created_at FROM memories WHERE id=?");
+        const touch = this.db.prepare("UPDATE memories SET hits=hits+1, accessed_at=? WHERE id=?");
+        const out = [];
+        for (const r of rows) {
+            const m = get.get(Number(r.rowid));
+            if (!m || (project && m.project !== project))
+                continue;
+            touch.run(Date.now(), m.id);
+            out.push({ id: m.id, project: m.project, text: open(this.fieldKey, m.content),
+                score: +(1 - (r.distance ** 2) / 2).toFixed(3), createdAt: m.created_at });
+            if (out.length >= limit)
+                break;
+        }
+        return filterRelevant(out);
+    }
+    forget(id) {
+        return this.db.transaction(() => {
+            this.db.prepare("DELETE FROM vec_memories WHERE rowid=?").run(BigInt(id));
+            return this.db.prepare("DELETE FROM memories WHERE id=?").run(id).changes > 0;
+        })();
+    }
+    stats() {
+        const r = this.db.prepare("SELECT COUNT(*) n, COALESCE(SUM(compacted),0) c FROM memories").get();
+        return { memories: r.n, compacted: r.c, path: join(HOME, "memory.db") };
+    }
+    /** Merge near-duplicate old memories (per project). E5 cosines run high, so threshold ~0.93. */
+    async compact(olderThanDays = 30, threshold = 0.93) {
+        const cutoff = Date.now() - olderThanDays * 864e5;
+        const rows = this.db.prepare("SELECT id,project,content,created_at FROM memories WHERE created_at < ? AND compacted = 0").all(cutoff);
+        const byProject = new Map();
+        for (const r of rows) {
+            if (!byProject.has(r.project))
+                byProject.set(r.project, []);
+            byProject.get(r.project).push(r);
+        }
+        const getVec = this.db.prepare("SELECT embedding FROM vec_memories WHERE rowid=?");
+        let merged = 0, removed = 0;
+        for (const [project, items] of byProject) {
+            const vecs = items.map((r) => toF32(getVec.get(BigInt(r.id)).embedding));
+            for (const g of cluster(vecs, threshold)) {
+                if (g.length < 2)
+                    continue;
+                const text = mergeTexts(g.map((i) => open(this.fieldKey, items[i].content)));
+                const vec = await embedPassage(text);
+                this.db.transaction(() => {
+                    this.put(project, text, vec, 1, Math.min(...g.map((i) => items[i].created_at)));
+                    for (const i of g) {
+                        this.db.prepare("DELETE FROM vec_memories WHERE rowid=?").run(BigInt(items[i].id));
+                        this.db.prepare("DELETE FROM memories WHERE id=?").run(items[i].id);
+                    }
+                })();
+                merged++;
+                removed += g.length;
+            }
+        }
+        return { merged, removed };
+    }
+}
+/** E5 scores are compressed (~0.7-0.9), so cut relative to the best hit, not by a fixed score. */
+function filterRelevant(h, margin = Number(process.env.MEMORY_BRIDGE_MARGIN ?? 0.04), floor = 0.7) {
+    if (!h.length)
+        return h;
+    const top = h[0].score;
+    return h.filter((x) => x.score >= floor && x.score >= top - margin);
+}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "local-ai-memory-bridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Encrypted, offline long-term memory for AI agents via MCP",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "memory-bridge": "dist/cli.js"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^4.3.2",
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@napi-rs/keyring": "^2.1.2",
+    "better-sqlite3-multiple-ciphers": "^13.0.3",
+    "commander": "^15.0.0",
+    "sqlite-vec": "^0.1.9",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^9.6.0",
+    "@types/node": "^26.6.6",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/radwanalmsora/local-ai-memory-bridge.git"
+  },
+  "files": [
+    "dist"
+  ]
+}