coolmem 1.0.0

package/README.md

@@ -0,0 +1,175 @@
+# 🧠 coolmem — Cross-Agent Memory Fabric
+
+A **privacy-first MCP server** that lets different AI agents (Cursor, Claude Desktop, etc.)
+share a persistent **Knowledge Ledger** — powered by local vector embeddings and SQLite.
+
+No API keys. No data leaves your machine.
+
+---
+
+## Architecture at a Glance
+
+```
+Agent A (Cursor)                 Agent B (Claude)
+     │                                │
+     │  store_memory(content, cat)    │  search_memories(query)
+     ▼                                ▼
+┌──────────────  MCP  stdio  ─────────────────┐
+│               coolmem server                │
+│  ┌────────────────────────────────────────┐ │
+│  │  @xenova/transformers                  │ │
+│  │  all-MiniLM-L6-v2 (384-dim, local CPU) │ │
+│  └────────────────┬───────────────────────┘ │
+│                   │  embed()                 │
+│  ┌────────────────▼───────────────────────┐ │
+│  │  SQLite  (coolmem.db)                  │ │
+│  │  Memory { id, content, category,       │ │
+│  │           embedding JSON, createdAt }  │ │
+│  └────────────────────────────────────────┘ │
+└─────────────────────────────────────────────┘
+```
+
+---
+
+## Quick Start
+
+```bash
+# 1. Install dependencies
+npm install
+
+# 2. Generate Prisma client + create the SQLite DB
+npx prisma generate
+npx prisma db push
+
+# 3. Build
+npm run build
+
+# 4. Run (for manual testing)
+node dist/index.js
+```
+
+The server communicates over **stdio** — you don't call it directly.
+Hook it into Claude Desktop or Cursor via the config below.
+
+---
+
+## Connecting to Claude Desktop
+
+Open (or create) your `claude_desktop_config.json`:
+
+- **macOS / Linux**: `~/.config/claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+Add the following block (adjust the path to match where you cloned this repo):
+
+```json
+{
+  "mcpServers": {
+    "coolmem": {
+      "command": "node",
+      "args": ["C:/Users/Dell/Desktop/YCU/coolmem/dist/index.js"],
+      "env": {
+        "DATABASE_URL": "file:C:/Users/Dell/Desktop/YCU/coolmem/coolmem.db"
+      }
+    }
+  }
+}
+```
+
+> **Tip:** After editing the config, restart Claude Desktop. You should see
+> `coolmem` appear in the Connected Servers list.
+
+---
+
+## Connecting to Cursor
+
+In Cursor → Settings → MCP → Add New MCP Server:
+
+| Field   | Value                                                      |
+|---------|------------------------------------------------------------|
+| Name    | `coolmem`                                                  |
+| Command | `node`                                                     |
+| Args    | `C:/Users/Dell/Desktop/YCU/coolmem/dist/index.js`         |
+| Env     | `DATABASE_URL=file:C:/Users/Dell/Desktop/YCU/coolmem/coolmem.db` |
+
+---
+
+## Available MCP Primitives
+
+### 🔧 Tool: `store_memory`
+
+Store a lesson learned, architectural decision, or any project knowledge.
+
+| Parameter  | Type   | Description                                          |
+|------------|--------|------------------------------------------------------|
+| `content`  | string | The knowledge text to persist                        |
+| `category` | string | Label: `architecture`, `bug-fix`, `decision`, etc.   |
+
+**Example agent prompt:**
+> Use the `store_memory` tool. content: "We switched from REST to tRPC because it eliminates
+> manual type duplication between client and server." category: "architecture"
+
+---
+
+### 🔧 Tool: `search_memories`
+
+Semantically search the ledger with a natural-language query.
+
+| Parameter | Type   | Description                   |
+|-----------|--------|-------------------------------|
+| `query`   | string | What you want to know about   |
+
+Returns the **top 3 most relevant memories** with cosine-similarity scores.
+
+**Example agent prompt:**
+> Use `search_memories`. query: "Why did we change our API layer?"
+
+---
+
+### 📄 Resource: `project_timeline`
+
+**URI:** `memory://coolmem/timeline`
+
+A chronological list of the **last 10 things** the agents stored — useful for
+onboarding a fresh agent to the current state of a project.
+
+---
+
+## Project Structure
+
+```
+coolmem/
+├── src/
+│   ├── index.ts          # MCP server — tools & resource definitions
+│   ├── embeddings.ts     # @xenova/transformers wrapper (lazy singleton)
+│   ├── similarity.ts     # Cosine similarity function
+│   └── db.ts             # Prisma client singleton
+├── prisma/
+│   └── schema.prisma     # Memory model → SQLite
+├── dist/                 # Compiled output (git-ignored)
+├── models/               # Cached model weights (auto-downloaded, git-ignored)
+├── coolmem.db            # SQLite database (git-ignored)
+├── .env                  # DATABASE_URL
+├── package.json
+└── tsconfig.json
+```
+
+---
+
+## First-Run Note on Model Download
+
+On the **very first call** to either tool, `@xenova/transformers` will download
+`all-MiniLM-L6-v2` (~22 MB) into the `./models/` folder. Subsequent calls use
+the cached weights instantly. This is a one-time cost.
+
+---
+
+## Extending This Server
+
+| Want to add…                  | How                                                              |
+|-------------------------------|------------------------------------------------------------------|
+| Delete a memory               | Add a `delete_memory(id)` tool via `server.tool()`              |
+| List memories by category     | Add a `list_memories(category)` tool                            |
+| More search results           | Change `.slice(0, 3)` to `.slice(0, N)` in `index.ts`          |
+| Faster vector search at scale | Swap the JS cosine loop for `sqlite-vss` or `usearch`          |
+| Different model               | Change `MODEL_NAME` in `embeddings.ts`                          |

package/dist/db.d.ts

@@ -0,0 +1,17 @@
+/**
+ * db.ts — Prisma Client singleton with automatic directory creation
+ *
+ * This version ensures the database and models are stored in a persistent
+ * folder in the user's home directory (~/.coolmem), making it portable for NPX.
+ */
+import { PrismaClient } from "@prisma/client";
+declare const COOLMEM_DIR: string;
+declare const prisma: PrismaClient<{
+    datasources: {
+        db: {
+            url: string;
+        };
+    };
+}, never, import("@prisma/client/runtime/library").DefaultArgs>;
+export default prisma;
+export { COOLMEM_DIR };

package/dist/db.js

@@ -0,0 +1,26 @@
+/**
+ * db.ts — Prisma Client singleton with automatic directory creation
+ *
+ * This version ensures the database and models are stored in a persistent
+ * folder in the user's home directory (~/.coolmem), making it portable for NPX.
+ */
+import { PrismaClient } from "@prisma/client";
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+// 1. Ensure the persistent data folder exists
+const COOLMEM_DIR = join(homedir(), ".coolmem");
+mkdirSync(COOLMEM_DIR, { recursive: true });
+// 2. Derive the database file path
+const dbPath = join(COOLMEM_DIR, "memories.db");
+// 3. Initialize Prisma with the explicit URL to bypass .env requirements
+const prisma = new PrismaClient({
+    datasources: {
+        db: {
+            url: `file:${dbPath}?connection_limit=1`,
+        },
+    },
+});
+export default prisma;
+export { COOLMEM_DIR };
+//# sourceMappingURL=db.js.map

package/dist/db.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.js","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAE/B,8CAA8C;AAC9C,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,CAAC,CAAC;AAChD,SAAS,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAE5C,mCAAmC;AACnC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;AAEhD,yEAAyE;AACzE,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC;IAC9B,WAAW,EAAE;QACX,EAAE,EAAE;YACF,GAAG,EAAE,QAAQ,MAAM,qBAAqB;SACzC;KACF;CACF,CAAC,CAAC;AAEH,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/embeddings.d.ts

@@ -0,0 +1,19 @@
+/**
+ * embeddings.ts — Local embedding generation via @xenova/transformers
+ *
+ * We use 'Xenova/all-MiniLM-L6-v2', a small (22 MB) sentence-transformer
+ * model that runs entirely on your CPU — no API keys, no data leaves your
+ * machine. It produces 384-dimensional float32 embeddings.
+ *
+ * The pipeline is initialised lazily (first call) and then cached, so the
+ * model is only loaded once per server process.
+ */
+/**
+ * Converts a text string into a 384-dimensional embedding vector.
+ * Mean-pooling is applied over the token dimension so the output is
+ * always a flat `number[]` regardless of input length.
+ *
+ * @param text - The raw string to embed
+ * @returns   A flat number[] of length 384
+ */
+export declare function embed(text: string): Promise<number[]>;

package/dist/embeddings.js

@@ -0,0 +1,46 @@
+/**
+ * embeddings.ts — Local embedding generation via @xenova/transformers
+ *
+ * We use 'Xenova/all-MiniLM-L6-v2', a small (22 MB) sentence-transformer
+ * model that runs entirely on your CPU — no API keys, no data leaves your
+ * machine. It produces 384-dimensional float32 embeddings.
+ *
+ * The pipeline is initialised lazily (first call) and then cached, so the
+ * model is only loaded once per server process.
+ */
+// @xenova/transformers is ESM-only; the dynamic import below is intentional.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let pipelineInstance = null;
+const MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
+import { join } from "path";
+import { COOLMEM_DIR } from "./db.js";
+/**
+ * Returns the cached feature-extraction pipeline, loading it on first call.
+ * On first use it will download the model weights (~22 MB) into a local cache.
+ */
+async function getPipeline() {
+    if (!pipelineInstance) {
+        // Dynamic import keeps the ESM-only package compatible with our build
+        const { pipeline, env } = await import("@xenova/transformers");
+        // Store model files in the persistent folder (~/.coolmem/models)
+        env.cacheDir = join(COOLMEM_DIR, "models");
+        pipelineInstance = await pipeline("feature-extraction", MODEL_NAME);
+    }
+    return pipelineInstance;
+}
+/**
+ * Converts a text string into a 384-dimensional embedding vector.
+ * Mean-pooling is applied over the token dimension so the output is
+ * always a flat `number[]` regardless of input length.
+ *
+ * @param text - The raw string to embed
+ * @returns   A flat number[] of length 384
+ */
+export async function embed(text) {
+    const extractor = await getPipeline();
+    // { pooling: "mean", normalize: true } → sentence embedding best practice
+    const output = await extractor(text, { pooling: "mean", normalize: true });
+    // output.data is a Float32Array; convert to a plain JS array
+    return Array.from(output.data);
+}
+//# sourceMappingURL=embeddings.js.map

package/dist/embeddings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.js","sourceRoot":"","sources":["../src/embeddings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,6EAA6E;AAC7E,8DAA8D;AAC9D,IAAI,gBAAgB,GAAe,IAAI,CAAC;AAExC,MAAM,UAAU,GAAG,yBAAyB,CAAC;AAE7C,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC;;;GAGG;AACH,KAAK,UAAU,WAAW;IACxB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,sEAAsE;QACtE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;QAE/D,iEAAiE;QACjE,GAAG,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAE3C,gBAAgB,GAAG,MAAM,QAAQ,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,IAAY;IACtC,MAAM,SAAS,GAAG,MAAM,WAAW,EAAE,CAAC;IAEtC,0EAA0E;IAC1E,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE3E,6DAA6D;IAC7D,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAoB,CAAC,CAAC;AACjD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * index.ts — Cross-Agent Memory Fabric: MCP Server (v2 — Optimized)
+ *
+ * This version separates the tool definitions and logic into separate files:
+ * - tools.ts: MCP tool and resource registrations
+ * - logic.ts: Business logic (Prisma, embeddings, etc.)
+ * - utils.ts: Constants and encoders
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * index.ts — Cross-Agent Memory Fabric: MCP Server (v2 — Optimized)
+ *
+ * This version separates the tool definitions and logic into separate files:
+ * - tools.ts: MCP tool and resource registrations
+ * - logic.ts: Business logic (Prisma, embeddings, etc.)
+ * - utils.ts: Constants and encoders
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerTools } from "./tools.js";
+import { execSync } from "child_process";
+import { join } from "path";
+import { existsSync, writeFileSync } from "fs";
+import { COOLMEM_DIR } from "./db.js";
+// ── Database Auto-Initialization ──────────────────────────────────────────────
+/**
+ * Ensures the database schema is applied. Runs 'prisma db push' on first launch.
+ * This makes the server "Plug and Play" for new users via npx.
+ */
+function ensureDatabaseIsReady() {
+    const flagFile = join(COOLMEM_DIR, ".pristine");
+    if (!existsSync(flagFile)) {
+        process.stderr.write("[coolmem] First run detected. Initializing database schema…\n");
+        try {
+            // We use the prisma CLI directly. Since it's a devDependency, 
+            // it will be available in the node_modules when installed via npm/npx.
+            execSync("npx prisma db push --accept-data-loss", {
+                stdio: "inherit",
+                env: { ...process.env, DATABASE_URL: `file:${join(COOLMEM_DIR, "memories.db")}` }
+            });
+            writeFileSync(flagFile, "Initialised at " + new Date().toISOString());
+            process.stderr.write("[coolmem] Database initialization complete.\n");
+        }
+        catch (err) {
+            process.stderr.write(`[coolmem] Warning: Auto-init failed. You may need to run 'npx prisma db push' manually. Error: ${err}\n`);
+        }
+    }
+}
+// ── Server bootstrap ──────────────────────────────────────────────────────────
+const server = new McpServer({ name: "coolmem", version: "2.0.0" });
+// Register all tools and resources
+registerTools(server);
+// ── Start ─────────────────────────────────────────────────────────────────────
+async function main() {
+    // Ensure DB is ready before connecting transport
+    ensureDatabaseIsReady();
+    const transport = new StdioServerTransport();
+    process.stderr.write("[coolmem v2] Cross-Agent Memory Fabric starting…\n");
+    await server.connect(transport);
+    process.stderr.write("[coolmem v2] Connected via stdio. Ready.\n");
+}
+main().catch((err) => {
+    process.stderr.write(`[coolmem v2] Fatal: ${err}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,iFAAiF;AAEjF;;;GAGG;AACH,SAAS,qBAAqB;IAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAChD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACtF,IAAI,CAAC;YACH,+DAA+D;YAC/D,uEAAuE;YACvE,QAAQ,CAAC,uCAAuC,EAAE;gBAChD,KAAK,EAAE,SAAS;gBAChB,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,QAAQ,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,EAAE,EAAE;aAClF,CAAC,CAAC;YACH,aAAa,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;YACtE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACxE,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,kGAAkG,GAAG,IAAI,CAAC,CAAC;QAClI,CAAC;IACH,CAAC;AACH,CAAC;AAED,iFAAiF;AAEjF,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;AAEpE,mCAAmC;AACnC,aAAa,CAAC,MAAM,CAAC,CAAC;AAEtB,iFAAiF;AAEjF,KAAK,UAAU,IAAI;IACjB,iDAAiD;IACjD,qBAAqB,EAAE,CAAC;IAExB,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC7C,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,oDAAoD,CAAC,CAAC;IAC3E,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC;AACrE,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;IACrD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/logic.d.ts

@@ -0,0 +1,56 @@
+/**
+ * logic.ts — Core business logic for the Cross-Agent Memory Fabric
+ */
+interface StoreMemoryParams {
+    content: string;
+    category: string;
+    project: string;
+}
+interface SearchMemoriesParams {
+    query: string;
+    project?: string;
+    limit: number;
+}
+interface UpdateMemoryParams {
+    id: number;
+    content?: string;
+    category?: string;
+}
+export declare function storeMemory({ content, category, project }: StoreMemoryParams): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function searchMemories({ query, project, limit }: SearchMemoriesParams): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function deleteMemory(id: number): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function updateMemory({ id, content, category }: UpdateMemoryParams): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function listProjects(): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function getProjectTimeline(): Promise<{
+    contents: {
+        uri: string;
+        text: string;
+        mimeType: "text/plain";
+    }[];
+}>;
+export {};

package/dist/logic.js

@@ -0,0 +1,180 @@
+/**
+ * logic.ts — Core business logic for the Cross-Agent Memory Fabric
+ */
+import prisma from "./db.js";
+import { embed } from "./embeddings.js";
+import { cosineSimilarity } from "./similarity.js";
+import { DEDUP_THRESHOLD, MIN_SCORE_THRESHOLD, encodeEmbedding, decodeEmbedding } from "./utils.js";
+export async function storeMemory({ content, category, project }) {
+    // ① Generate local embedding
+    const vector = await embed(content);
+    // ② Deduplication: scan existing memories in this project for near-duplicates
+    const existing = await prisma.memory.findMany({
+        where: { project },
+        select: { id: true, embedding: true },
+    });
+    for (const m of existing) {
+        const score = cosineSimilarity(vector, decodeEmbedding(m.embedding));
+        if (score >= DEDUP_THRESHOLD) {
+            // ③ Near-duplicate found — update in place
+            const updated = await prisma.memory.update({
+                where: { id: m.id },
+                data: { content, category, embedding: encodeEmbedding(vector) },
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `♻️ Near-duplicate detected (score: ${score.toFixed(4)}). Updated Memory #${updated.id} in [${project}] instead of creating a duplicate.`,
+                    }],
+            };
+        }
+    }
+    // ④ No duplicate — insert new memory
+    const memory = await prisma.memory.create({
+        data: { content, category, project, embedding: encodeEmbedding(vector) },
+    });
+    return {
+        content: [{
+                type: "text",
+                text: `✅ Memory #${memory.id} stored in project [${project}].\nCategory: ${category}\nPreview: "${content.slice(0, 120)}${content.length > 120 ? "…" : ""}"`,
+            }],
+    };
+}
+export async function searchMemories({ query, project, limit }) {
+    // ① Embed the query
+    const queryVector = await embed(query);
+    // ② Fetch relevant memories
+    const allMemories = await prisma.memory.findMany({
+        where: project ? { project } : undefined,
+        select: { id: true, content: true, category: true, project: true, embedding: true, createdAt: true },
+    });
+    if (allMemories.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: project
+                        ? `📭 No memories found for project "${project}". Use store_memory to add the first entry.`
+                        : "📭 The memory ledger is empty. Use store_memory to add the first entry.",
+                }],
+        };
+    }
+    // ③ Score + decode in one pass
+    const scored = allMemories
+        .map((m) => ({ ...m, score: cosineSimilarity(queryVector, decodeEmbedding(m.embedding)) }))
+        .filter((m) => m.score >= MIN_SCORE_THRESHOLD)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    if (scored.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `🔍 No memories scored above the relevance threshold (${MIN_SCORE_THRESHOLD}) for: "${query}"\n\nTry rephrasing or broadening your query.`,
+                }],
+        };
+    }
+    const formatted = scored
+        .map((m, i) => `#${i + 1} [score: ${m.score.toFixed(4)}, project: "${m.project}", category: "${m.category}", id: ${m.id}]\n${m.content}`)
+        .join("\n\n---\n\n");
+    return {
+        content: [{
+                type: "text",
+                text: `🔍 ${scored.length} result${scored.length > 1 ? "s" : ""} for: "${query}"\n\n${formatted}`,
+            }],
+    };
+}
+export async function deleteMemory(id) {
+    const existing = await prisma.memory.findUnique({ where: { id }, select: { id: true, content: true } });
+    if (!existing) {
+        return {
+            content: [{ type: "text", text: `❌ Memory #${id} not found. It may have already been deleted.` }],
+        };
+    }
+    await prisma.memory.delete({ where: { id } });
+    return {
+        content: [{
+                type: "text",
+                text: `🗑️ Memory #${id} deleted.\nDeleted content: "${existing.content.slice(0, 100)}${existing.content.length > 100 ? "…" : ""}"`,
+            }],
+    };
+}
+export async function updateMemory({ id, content, category }) {
+    const existing = await prisma.memory.findUnique({ where: { id } });
+    if (!existing) {
+        return {
+            content: [{ type: "text", text: `❌ Memory #${id} not found.` }],
+        };
+    }
+    const newEmbedding = content ? encodeEmbedding(await embed(content)) : undefined;
+    const updated = await prisma.memory.update({
+        where: { id },
+        data: {
+            ...(content && { content }),
+            ...(category && { category }),
+            ...(newEmbedding && { embedding: newEmbedding }),
+        },
+    });
+    return {
+        content: [{
+                type: "text",
+                text: [
+                    `✏️ Memory #${updated.id} updated.`,
+                    content ? `   Content : "${updated.content.slice(0, 100)}…"` : null,
+                    category ? `   Category: ${updated.category}` : null,
+                    content ? "   Embedding regenerated." : null,
+                ].filter(Boolean).join("\n"),
+            }],
+    };
+}
+export async function listProjects() {
+    const groups = await prisma.memory.groupBy({
+        by: ["project"],
+        _count: { _all: true },
+    });
+    if (groups.length === 0) {
+        return {
+            content: [{ type: "text", text: "📭 No projects found in the ledger." }],
+        };
+    }
+    const list = groups
+        .map((g) => `- **${g.project}**: ${g._count._all} memories`)
+        .sort()
+        .join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `📂 **Available Projects:**\n\n${list}`,
+            },
+        ],
+    };
+}
+export async function getProjectTimeline() {
+    const recent = await prisma.memory.findMany({
+        orderBy: { createdAt: "desc" },
+        take: 10,
+        select: { id: true, content: true, category: true, project: true, createdAt: true },
+    });
+    if (recent.length === 0) {
+        return {
+            contents: [{
+                    uri: "memory://coolmem/timeline",
+                    text: "No memories have been stored yet.",
+                    mimeType: "text/plain",
+                }],
+        };
+    }
+    const lines = recent.map((m) => {
+        const ts = m.createdAt.toISOString().replace("T", " ").slice(0, 19);
+        return `[${ts}] #${m.id} | project: ${m.project} | ${m.category}\n  ${m.content.slice(0, 200)}${m.content.length > 200 ? "…" : ""}`;
+    });
+    return {
+        contents: [{
+                uri: "memory://coolmem/timeline",
+                mimeType: "text/plain",
+                text: `📋 Project Timeline — Last ${recent.length} memories (newest first)\n` +
+                    `${"─".repeat(60)}\n\n` +
+                    lines.join("\n\n"),
+            }],
+    };
+}
+//# sourceMappingURL=logic.js.map

package/dist/logic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.js","sourceRoot":"","sources":["../src/logic.ts"],"names":[],"mappings":"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"}

package/dist/similarity.d.ts

@@ -0,0 +1,24 @@
+/**
+ * similarity.ts — Optimized dot-product similarity for normalized vectors
+ *
+ * WHY NOT FULL COSINE:
+ *   Full cosine = dot(a,b) / (|a| × |b|)
+ *   But embeddings.ts always uses { normalize: true }, so every vector from
+ *   all-MiniLM-L6-v2 is a unit vector (|v| = 1). The denominator is always
+ *   1×1 = 1, reducing to a pure dot product — saving 2 magnitude accumulators
+ *   + 2 Math.sqrt calls per comparison (~60% fewer ops across 384 dimensions).
+ *
+ * RESULT RANGE: still [-1, 1] — identical semantics to full cosine similarity.
+ *
+ * NOTE: If you ever change normalize to false in embeddings.ts, restore the
+ *       full cosine formula or pre-normalize vectors at write-time.
+ */
+/**
+ * Dot-product similarity for L2-normalized (unit) vectors.
+ * Semantically equivalent to cosine similarity when inputs are unit vectors.
+ *
+ * @param a - Unit vector (|a| = 1), length 384
+ * @param b - Unit vector (|b| = 1), length 384
+ * @returns  Score in [-1, 1]; higher = more similar
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;

package/dist/similarity.js

@@ -0,0 +1,31 @@
+/**
+ * similarity.ts — Optimized dot-product similarity for normalized vectors
+ *
+ * WHY NOT FULL COSINE:
+ *   Full cosine = dot(a,b) / (|a| × |b|)
+ *   But embeddings.ts always uses { normalize: true }, so every vector from
+ *   all-MiniLM-L6-v2 is a unit vector (|v| = 1). The denominator is always
+ *   1×1 = 1, reducing to a pure dot product — saving 2 magnitude accumulators
+ *   + 2 Math.sqrt calls per comparison (~60% fewer ops across 384 dimensions).
+ *
+ * RESULT RANGE: still [-1, 1] — identical semantics to full cosine similarity.
+ *
+ * NOTE: If you ever change normalize to false in embeddings.ts, restore the
+ *       full cosine formula or pre-normalize vectors at write-time.
+ */
+/**
+ * Dot-product similarity for L2-normalized (unit) vectors.
+ * Semantically equivalent to cosine similarity when inputs are unit vectors.
+ *
+ * @param a - Unit vector (|a| = 1), length 384
+ * @param b - Unit vector (|b| = 1), length 384
+ * @returns  Score in [-1, 1]; higher = more similar
+ */
+export function cosineSimilarity(a, b) {
+    let dot = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+    }
+    return dot;
+}
+//# sourceMappingURL=similarity.js.map

package/dist/similarity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.js","sourceRoot":"","sources":["../src/similarity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAW,EAAE,CAAW;IACvD,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACrB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/tools.d.ts

@@ -0,0 +1,8 @@
+/**
+ * tools.ts — MCP Tool and Resource definitions
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Registers all tools and resources to the given MCP server instance.
+ */
+export declare function registerTools(server: McpServer): void;

package/dist/tools.js

@@ -0,0 +1,38 @@
+/**
+ * tools.ts — MCP Tool and Resource definitions
+ */
+import { z } from "zod";
+import * as logic from "./logic.js";
+import { MAX_LIMIT } from "./utils.js";
+/**
+ * Registers all tools and resources to the given MCP server instance.
+ */
+export function registerTools(server) {
+    // ── TOOL 1: store_memory ───────────────────────────────────────────────────
+    server.tool("store_memory", "Store a lesson learned, architectural decision, or project knowledge into the shared memory ledger. Automatically deduplicates — if a near-identical memory already exists, it is updated rather than duplicated.", {
+        content: z.string().min(1).describe("The knowledge to persist. Be specific for better recall."),
+        category: z.string().min(1).describe('Label: "architecture", "bug-fix", "decision", "api-contract", "deployment", etc.'),
+        project: z.string().default("default").describe('Project namespace, e.g. "coolmem", "fastgistics". Keeps memories scoped. Defaults to "default".'),
+    }, async (params) => logic.storeMemory(params));
+    // ── TOOL 2: search_memories ────────────────────────────────────────────────
+    server.tool("search_memories", "Semantically search the shared knowledge ledger. Returns the top N most relevant memories above a minimum relevance threshold. Results below 0.30 cosine similarity are automatically excluded as irrelevant.", {
+        query: z.string().min(1).describe("Natural-language question or topic to search for."),
+        project: z.string().optional().describe('Restrict search to a specific project namespace. Omit to search all projects.'),
+        limit: z.number().int().min(1).max(MAX_LIMIT).default(3).describe(`Max results to return (1–${MAX_LIMIT}, default 3).`),
+    }, async (params) => logic.searchMemories(params));
+    // ── TOOL 3: delete_memory ──────────────────────────────────────────────────
+    server.tool("delete_memory", "Permanently delete a memory from the ledger by its ID. Use this when a decision has changed or information is outdated. The ID is shown in search results.", {
+        id: z.number().int().positive().describe("The numeric ID of the memory to delete (visible in search results)."),
+    }, async ({ id }) => logic.deleteMemory(id));
+    // ── TOOL 4: update_memory ──────────────────────────────────────────────────
+    server.tool("update_memory", "Update an existing memory's content and/or category. If content is updated, the embedding is automatically regenerated. Use this when a decision evolves rather than creating a duplicate.", {
+        id: z.number().int().positive().describe("The numeric ID of the memory to update."),
+        content: z.string().min(1).optional().describe("New content text. If provided, the embedding is regenerated automatically."),
+        category: z.string().min(1).optional().describe("New category label."),
+    }, async (params) => logic.updateMemory(params));
+    // ── TOOL 5: list_projects ──────────────────────────────────────────────────
+    server.tool("list_projects", "List all project namespaces currently stored in the memory ledger, along with the count of memories in each. Use this to discover what knowledge buckets are available.", {}, async () => logic.listProjects());
+    // ── RESOURCE: project_timeline ─────────────────────────────────────────────
+    server.resource("project_timeline", "memory://coolmem/timeline", async () => logic.getProjectTimeline());
+}
+//# sourceMappingURL=tools.js.map

package/dist/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,MAAiB;IAC7C,8EAA8E;IAC9E,MAAM,CAAC,IAAI,CACT,cAAc,EACd,mNAAmN,EACnN;QACE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,0DAA0D,CAAC;QAC/F,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,kFAAkF,CAAC;QACxH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,iGAAiG,CAAC;KACnJ,EACD,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAC5C,CAAC;IAEF,8EAA8E;IAC9E,MAAM,CAAC,IAAI,CACT,iBAAiB,EACjB,+MAA+M,EAC/M;QACE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,mDAAmD,CAAC;QACtF,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,+EAA+E,CAAC;QACxH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,4BAA4B,SAAS,eAAe,CAAC;KACxH,EACD,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAC/C,CAAC;IAEF,8EAA8E;IAC9E,MAAM,CAAC,IAAI,CACT,eAAe,EACf,4JAA4J,EAC5J;QACE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,qEAAqE,CAAC;KAChH,EACD,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,CACzC,CAAC;IAEF,8EAA8E;IAC9E,MAAM,CAAC,IAAI,CACT,eAAe,EACf,4LAA4L,EAC5L;QACE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;QACnF,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,4EAA4E,CAAC;QAC5H,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC;KACvE,EACD,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAC7C,CAAC;IAEF,8EAA8E;IAC9E,MAAM,CAAC,IAAI,CACT,eAAe,EACf,yKAAyK,EACzK,EAAE,EACF,KAAK,IAAI,EAAE,CAAC,KAAK,CAAC,YAAY,EAAE,CACjC,CAAC;IAEF,8EAA8E;IAC9E,MAAM,CAAC,QAAQ,CACb,kBAAkB,EAClB,2BAA2B,EAC3B,KAAK,IAAI,EAAE,CAAC,KAAK,CAAC,kBAAkB,EAAE,CACvC,CAAC;AACJ,CAAC"}

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * utils.ts — Embedding codecs and constants for the Memory Fabric
+ */
+/** Cosine score above which a new memory is considered a duplicate of an existing one */
+export declare const DEDUP_THRESHOLD = 0.88;
+/** Cosine score below which a search result is considered irrelevant and dropped */
+export declare const MIN_SCORE_THRESHOLD = 0.3;
+/** Maximum results a caller can request */
+export declare const MAX_LIMIT = 20;
+export declare function encodeEmbedding(vector: number[]): Buffer;
+export declare function decodeEmbedding(buf: Buffer): number[];

package/dist/utils.js

@@ -0,0 +1,23 @@
+/**
+ * utils.ts — Embedding codecs and constants for the Memory Fabric
+ */
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Cosine score above which a new memory is considered a duplicate of an existing one */
+export const DEDUP_THRESHOLD = 0.88;
+/** Cosine score below which a search result is considered irrelevant and dropped */
+export const MIN_SCORE_THRESHOLD = 0.30;
+/** Maximum results a caller can request */
+export const MAX_LIMIT = 20;
+// ── Binary embedding codec ────────────────────────────────────────────────────
+// Stores Float32 vectors as raw bytes: 384 × 4 B = 1,536 B per memory
+// vs ~4 KB as a JSON string — plus no JSON.parse() on every search.
+export function encodeEmbedding(vector) {
+    const f32 = new Float32Array(vector);
+    return Buffer.from(f32.buffer);
+}
+export function decodeEmbedding(buf) {
+    // Buffer is a Node.js subclass of Uint8Array; respect byteOffset for safety
+    const f32 = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+    return Array.from(f32);
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,iFAAiF;AAEjF,yFAAyF;AACzF,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,CAAC;AAEpC,oFAAoF;AACpF,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,CAAC;AAExC,2CAA2C;AAC3C,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAE5B,iFAAiF;AACjF,sEAAsE;AACtE,oEAAoE;AAEpE,MAAM,UAAU,eAAe,CAAC,MAAgB;IAC9C,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC;IACrC,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,4EAA4E;IAC5E,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;IAC7E,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "coolmem",
+  "version": "1.0.0",
+  "description": "Cross-Agent Memory Fabric — a privacy-first MCP server for shared AI memory with local vector embeddings.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "coolmem": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "start": "node dist/index.js",
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "db:push": "prisma db push",
+    "setup": "npm install && npx prisma db push && npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "@prisma/client": "^5.22.0",
+    "@xenova/transformers": "^2.17.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "prisma": "^5.22.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2"
+  }
+}

package/prisma/schema.prisma

@@ -0,0 +1,21 @@
+// Prisma schema for the coolmem Cross-Agent Memory Fabric
+// The "embedding" field stores a JSON-serialized float32 array
+// produced by the all-MiniLM-L6-v2 model (384 dimensions).
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+model Memory {
+  id        Int      @id @default(autoincrement())
+  content   String   // The raw text that was "learned"
+  category  String   // e.g. "architecture", "bug-fix", "decision", "api-contract"
+  project   String   @default("default") // Scopes memories per project — prevents cross-project pollution
+  embedding Bytes    // Float32Array as binary BLOB: 384 × 4 bytes = 1,536 bytes (vs ~4 KB as JSON)
+  createdAt DateTime @default(now())
+}

package/seed.mjs

@@ -0,0 +1,69 @@
+/**
+ * seed.mjs — stores architectural decisions about coolmem into coolmem itself.
+ * Run once: node seed.mjs
+ */
+import { PrismaClient } from "@prisma/client";
+import { pipeline, env } from "@xenova/transformers";
+
+const prisma = new PrismaClient();
+env.cacheDir = "./models";
+
+function encodeEmbedding(vector) {
+    return Buffer.from(new Float32Array(vector).buffer);
+}
+function decodeEmbedding(buf) {
+    return Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
+}
+function dotProduct(a, b) {
+    let dot = 0;
+    for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
+    return dot;
+}
+
+const DEDUP = 0.88;
+
+process.stdout.write("⏳ Loading model…\n");
+const extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+process.stdout.write("✅ Model ready.\n\n");
+
+async function embed(text) {
+    const out = await extractor(text, { pooling: "mean", normalize: true });
+    return Array.from(out.data);
+}
+
+async function store(content, category, project = "coolmem") {
+    const vec = await embed(content);
+    const existing = await prisma.memory.findMany({ where: { project }, select: { id: true, embedding: true } });
+    for (const m of existing) {
+        if (dotProduct(vec, decodeEmbedding(m.embedding)) >= DEDUP) {
+            await prisma.memory.update({ where: { id: m.id }, data: { content, category, embedding: encodeEmbedding(vec) } });
+            process.stdout.write(`♻️  Updated #${m.id} (duplicate)\n`);
+            return;
+        }
+    }
+    const r = await prisma.memory.create({ data: { content, category, project, embedding: encodeEmbedding(vec) } });
+    process.stdout.write(`✅ Stored #${r.id} [${category}]\n`);
+}
+
+await store(
+    "cosineSimilarity in similarity.ts is implemented as a pure dot product, not full cosine. This is correct and optimal because embeddings.ts always uses { normalize: true } with all-MiniLM-L6-v2, making every vector a unit vector (magnitude = 1). For unit vectors, cosine similarity = dot product. This saves ~60% of operations per comparison: removes 2 magnitude accumulators and 2 Math.sqrt calls across all 384 dimensions. If normalize is ever changed to false, full cosine must be restored.",
+    "architecture"
+);
+
+await store(
+    "Similarity search is brute-force O(n): all embeddings are loaded into RAM and scored per query. This is fine up to ~1,000 memories. Beyond that, switch to sqlite-vss (ANN index inside SQLite) or ChromaDB. Each embedding costs 1,536 bytes as Float32 BLOB.",
+    "architecture"
+);
+
+await store(
+    "DEDUP_THRESHOLD = 0.88 for store_memory deduplication. 0.95 was too strict (missed paraphrased rewrites of the same fact). 0.88 catches semantic duplicates without false-positives on genuinely different memories. MIN_SCORE_THRESHOLD = 0.30 for search (below this, results are irrelevant noise).",
+    "decision"
+);
+
+await store(
+    "all-MiniLM-L6-v2 (Xenova) is loaded lazily on first tool call and cached in ./models/. First-run downloads ~22 MB. It produces 384-dimensional L2-normalized float32 sentence embeddings. The pipeline instance is a module-level singleton — only one load per server process regardless of how many tool calls arrive.",
+    "architecture"
+);
+
+await prisma.$disconnect();
+process.stdout.write("\n🎉 coolmem seeded with its own architecture decisions.\n");

package/test.mjs

@@ -0,0 +1,185 @@
+/**
+ * test.mjs — Integration test for coolmem v2 (all optimizations)
+ * Run with:  node test.mjs
+ */
+
+import { PrismaClient } from "@prisma/client";
+import { pipeline, env } from "@xenova/transformers";
+
+// ── color helpers ─────────────────────────────────────────────────────────────
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const hr = (c = "─", n = 60) => c.repeat(n);
+
+// ── binary codec (mirrors src/index.ts) ───────────────────────────────────────
+function encodeEmbedding(vector) {
+    return Buffer.from(new Float32Array(vector).buffer);
+}
+function decodeEmbedding(buf) {
+    return Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
+}
+function cosineSimilarity(a, b) {
+    let dot = 0, magA = 0, magB = 0;
+    for (let i = 0; i < a.length; i++) { dot += a[i] * b[i]; magA += a[i] * a[i]; magB += b[i] * b[i]; }
+    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+
+// ── setup ─────────────────────────────────────────────────────────────────────
+const prisma = new PrismaClient();
+env.cacheDir = "./models";
+let extractor;
+
+async function loadModel() {
+    process.stdout.write(yellow("⏳ Loading model…\n"));
+    extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+    process.stdout.write(green("✅ Model ready.\n\n"));
+}
+async function embed(text) {
+    const out = await extractor(text, { pooling: "mean", normalize: true });
+    return Array.from(out.data);
+}
+
+// ── tool simulations ──────────────────────────────────────────────────────────
+const DEDUP_THRESHOLD = 0.95;
+const MIN_SCORE = 0.30;
+
+async function storeMemory(content, category, project = "default") {
+    const vector = await embed(content);
+    const existing = await prisma.memory.findMany({ where: { project }, select: { id: true, embedding: true } });
+    for (const m of existing) {
+        const score = cosineSimilarity(vector, decodeEmbedding(m.embedding));
+        if (score >= DEDUP_THRESHOLD) {
+            await prisma.memory.update({ where: { id: m.id }, data: { content, category, embedding: encodeEmbedding(vector) } });
+            return { id: m.id, duplicate: true, score };
+        }
+    }
+    const r = await prisma.memory.create({ data: { content, category, project, embedding: encodeEmbedding(vector) } });
+    return { id: r.id, duplicate: false };
+}
+
+async function searchMemories(query, project, limit = 3) {
+    const qVec = await embed(query);
+    const all = await prisma.memory.findMany({
+        where: project ? { project } : undefined,
+        select: { id: true, content: true, category: true, project: true, embedding: true }
+    });
+    return all
+        .map(m => ({ ...m, score: cosineSimilarity(qVec, decodeEmbedding(m.embedding)) }))
+        .filter(m => m.score >= MIN_SCORE)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+}
+
+async function deleteMemory(id) {
+    return prisma.memory.delete({ where: { id } });
+}
+
+async function updateMemory(id, content, category) {
+    const newEmbed = content ? encodeEmbedding(await embed(content)) : undefined;
+    return prisma.memory.update({
+        where: { id }, data: {
+            ...(content && { content }), ...(category && { category }), ...(newEmbed && { embedding: newEmbed }),
+        }
+    });
+}
+
+// ── test runner ───────────────────────────────────────────────────────────────
+async function main() {
+    console.log("\n" + bold("🧠 coolmem v2 — Integration Test"));
+    console.log(hr("═") + "\n");
+    await loadModel();
+
+    // PHASE 1 — Store (two projects)
+    console.log(bold("PHASE 1 — store_memory (with project scoping)"));
+    console.log(hr() + "\n");
+    const toStore = [
+        { content: "We use SQLite with Prisma ORM. Embeddings stored as binary BLOBs (Float32Array).", category: "architecture", project: "coolmem" },
+        { content: "all-MiniLM-L6-v2 runs locally on CPU: 22 MB, 384-dim, zero API cost.", category: "decision", project: "coolmem" },
+        { content: "MCP server uses stdio transport — never write to stdout or you corrupt the protocol.", category: "architecture", project: "coolmem" },
+        { content: "The admin dashboard uses MongoDB with Next.js API routes for the revenue KPI endpoint.", category: "architecture", project: "admin-dashboard" },
+    ];
+    for (const m of toStore) {
+        const r = await storeMemory(m.content, m.category, m.project);
+        const tag = r.duplicate ? yellow(`♻️  Deduplicated → updated #${r.id} (score ${r.score?.toFixed(4)})`) : green(`✅ Stored as #${r.id}`);
+        console.log(`   [${m.project}] ${tag}`);
+        console.log(dim(`   "${m.content.slice(0, 80)}…"\n`));
+    }
+
+    // PHASE 2 — Deduplication
+    console.log(bold("PHASE 2 — Deduplication (store near-identical content)"));
+    console.log(hr() + "\n");
+    const dupResult = await storeMemory(
+        "all-MiniLM-L6-v2 runs on CPU locally: 22 MB model, produces 384-dimensional embeddings, no API key needed.",
+        "decision", "coolmem"
+    );
+    if (dupResult.duplicate) {
+        console.log(yellow(`   ♻️  Correctly detected duplicate! Updated #${dupResult.id} (score: ${dupResult.score.toFixed(4)})\n`));
+    } else {
+        console.log(red(`   ❌ Duplicate NOT detected — threshold may need tuning.\n`));
+    }
+
+    // PHASE 3 — Search (project-scoped + score threshold)
+    console.log(bold("PHASE 3 — search_memories (scoped + score threshold 0.30)"));
+    console.log(hr() + "\n");
+    const queries = [
+        { q: "how are embeddings stored?", project: "coolmem" },
+        { q: "what AI model do we use?", project: "coolmem" },
+        { q: "what database does admin dashboard use?", project: "admin-dashboard" },
+        { q: "quantum physics lecture notes", project: undefined }, // should return nothing
+    ];
+    for (const { q, project } of queries) {
+        console.log(cyan(`   🔍 "${q}"${project ? ` [project: ${project}]` : " [all projects]"}`));
+        const results = await searchMemories(q, project);
+        if (results.length === 0) {
+            console.log(dim(`   → No results above threshold (correct for irrelevant query)\n`));
+        } else {
+            results.forEach((r, i) =>
+                console.log(`   #${i + 1} score=${r.score.toFixed(4)} [${r.project}/${r.category}]\n   ${dim(r.content.slice(0, 90) + "…")}`)
+            );
+            console.log();
+        }
+    }
+
+    // PHASE 4 — Update
+    console.log(bold("PHASE 4 — update_memory"));
+    console.log(hr() + "\n");
+    const all = await prisma.memory.findMany({ take: 1, orderBy: { id: "asc" }, select: { id: true, content: true } });
+    if (all.length > 0) {
+        const { id } = all[0];
+        await updateMemory(id, undefined, "architecture-v2"); // only category changed
+        console.log(green(`   ✅ Updated category of Memory #${id} to "architecture-v2" (no re-embed needed)\n`));
+    }
+
+    // PHASE 5 — Delete
+    console.log(bold("PHASE 5 — delete_memory"));
+    console.log(hr() + "\n");
+    const last = await prisma.memory.findFirst({ orderBy: { id: "desc" }, select: { id: true } });
+    if (last) {
+        await deleteMemory(last.id);
+        console.log(green(`   ✅ Deleted Memory #${last.id}\n`));
+    }
+
+    // PHASE 6 — Timeline
+    console.log(bold("PHASE 6 — project_timeline resource"));
+    console.log(hr() + "\n");
+    const timeline = await prisma.memory.findMany({
+        orderBy: { createdAt: "desc" }, take: 10,
+        select: { id: true, content: true, category: true, project: true, createdAt: true },
+    });
+    for (const m of timeline) {
+        const ts = m.createdAt.toISOString().replace("T", " ").slice(0, 19);
+        console.log(`   [${ts}] #${m.id} | ${m.project} | ${m.category}`);
+        console.log(dim(`   ${m.content.slice(0, 90)}…\n`));
+    }
+
+    console.log(hr("═"));
+    console.log(green(bold("🎉 All phases passed!")));
+
+    await prisma.$disconnect();
+}
+
+main().catch(e => { console.error(red("FATAL:"), e); prisma.$disconnect(); process.exit(1); });