mcp-simple-memory 0.1.0 → 0.2.0

package/README.md

@@ -1,27 +1,26 @@
 # mcp-simple-memory
 
-Persistent memory for Claude Code. **~500 lines, 1 file, zero external databases.**
+Persistent memory for Claude Code. **One file, zero external databases.**
 
 Claude Code forgets everything between sessions. This MCP server gives it a local SQLite memory that persists forever.
 
-## Why not claude-mem?
+## Why This Exists
 
 | | claude-mem | mcp-simple-memory |
 |---|-----------|-------------------|
-| Codebase | ~20,000 lines | ~500 lines |
+| Codebase | ~20,000 lines | ~600 lines |
 | External DB | ChromaDB + Python | None (SQLite built-in) |
 | Windows | Broken (as of v10) | Works |
 | Setup | Complex | 1 command |
-| Search | Vector only | FTS5 + optional vector |
+| Search | Vector only | Keyword + optional vector |
 
 ## Quick Start
 
 ```bash
-# In your project directory:
 npx mcp-simple-memory init
 ```
 
-Restart Claude Code. Done. You now have `mem_save`, `mem_search`, `mem_get`, and `mem_list` tools.
+Restart Claude Code. Done. You now have 7 tools: `mem_save`, `mem_search`, `mem_get`, `mem_list`, `mem_update`, `mem_delete`, `mem_tags`.
 
 ## Optional: Semantic Search
 
@@ -42,29 +41,40 @@ Edit `.mcp.json`:
 }
 ```
 
-Without a key, only FTS5 keyword search is used. With a key, the server automatically falls back to vector search when keyword search returns few results.
+Without a key, keyword search is used. With a key, vector search kicks in automatically when keyword results are sparse.
 
 ## Tools
 
 ### `mem_save`
-Save a memory.
+Save a memory with optional tags.
+
+```
+mem_save({ text: "OAuth2 tokens expire in 1 hour", tags: ["auth", "api"] })
+```
 
 | Param | Required | Description |
 |-------|----------|-------------|
 | text | Yes | Content to save |
 | title | No | Short title (auto-generated) |
 | project | No | Project name (default: "default") |
-| type | No | memory, decision, error, session_summary |
+| type | No | memory, decision, error, session_summary, todo, snippet |
+| tags | No | Array of tags for categorization |
 
 ### `mem_search`
-Search memories by keyword or meaning.
+Search by keyword, meaning, tag, or type.
+
+```
+mem_search({ query: "authentication", tag: "api" })
+```
 
 | Param | Required | Description |
 |-------|----------|-------------|
 | query | No | Search query (omit for recent) |
 | limit | No | Max results (default: 20) |
 | project | No | Filter by project |
-| mode | No | fts, vector, auto (default: auto) |
+| mode | No | keyword, vector, auto (default: auto) |
+| tag | No | Filter by tag |
+| type | No | Filter by type |
 
 ### `mem_get`
 Fetch full details by ID.
@@ -74,27 +84,70 @@ Fetch full details by ID.
 | ids | Yes | Array of memory IDs |
 
 ### `mem_list`
-List recent memories.
+List recent memories with optional filters.
 
 | Param | Required | Description |
 |-------|----------|-------------|
 | limit | No | Max results (default: 20) |
 | project | No | Filter by project |
+| type | No | Filter by type |
+| tag | No | Filter by tag |
+
+### `mem_update`
+Update an existing memory's content, title, type, project, or tags.
+
+```
+mem_update({ id: 42, text: "Updated content", tags: ["new-tag"] })
+```
+
+| Param | Required | Description |
+|-------|----------|-------------|
+| id | Yes | Memory ID to update |
+| text | No | New content |
+| title | No | New title |
+| type | No | New type |
+| project | No | New project |
+| tags | No | Replace all tags (pass [] to clear) |
+
+### `mem_delete`
+Delete memories by IDs. Also removes embeddings and tags.
+
+```
+mem_delete({ ids: [1, 2, 3] })
+```
+
+| Param | Required | Description |
+|-------|----------|-------------|
+| ids | Yes | Array of memory IDs to delete |
+
+### `mem_tags`
+List all tags with usage counts.
+
+```
+mem_tags({ project: "my-app" })
+```
+
+| Param | Required | Description |
+|-------|----------|-------------|
+| project | No | Filter by project |
 
 ## How It Works
 
 ```
-mem_save("Fixed the auth bug by switching to OAuth2")
-    ↓
-SQLite (FTS5 index + optional Gemini embedding)
-    ↓
-mem_search("authentication problem")
-    → Finds it via FTS keyword match OR vector similarity
+mem_save({ text: "Fixed auth bug with OAuth2", tags: ["bug", "auth"] })
+    |
+    v
+SQLite (keyword index + optional Gemini embedding + tags)
+    |
+    v
+mem_search({ query: "authentication problem", tag: "bug" })
+    -> Finds it via keyword match OR vector similarity, filtered by tag
 ```
 
-1. **FTS5**: SQLite full-text search. Fast, zero-config, keyword matching.
-2. **Gemini Embeddings** (optional): Converts text to 3072-dim vectors for semantic similarity. Free tier = 1500 requests/day.
-3. **Auto mode**: Tries FTS5 first. If < 3 results, falls back to vector search.
+1. **Keyword Search**: SQLite LIKE queries. Fast, zero-config.
+2. **Gemini Embeddings** (optional): 3072-dim vectors for semantic similarity. Free tier = 1500 req/day.
+3. **Auto mode**: Keyword first. If < 3 results, falls back to vector search.
+4. **Tags**: Lightweight categorization. Normalized to lowercase.
 
 ## Data Storage
 
@@ -111,8 +164,13 @@ Add to your project's `CLAUDE.md` for automatic session memory:
 - On session start: use `mem_search` to find recent session summaries
 - During work: save important decisions with `mem_save` (type: "decision")
 - On session end: save a summary with `mem_save` (type: "session_summary")
+- Tag memories for easy retrieval: `mem_save({ text: "...", tags: ["auth", "v2"] })`
 ```
 
+## Upgrade from 0.1.x
+
+Just update - the database schema migrates automatically. Your existing memories are preserved. New columns (`updated_at`, `updated_iso`) and the `tags` table are added on first run.
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 /**
- * mcp-simple-memory — Persistent memory for Claude Code
+ * mcp-simple-memory - Persistent memory for Claude Code
  *
- * ~450 lines. SQLite (sql.js WASM, zero native deps).
+ * SQLite (sql.js WASM, zero native deps).
  * Optional Gemini semantic search. Works on Windows/Mac/Linux.
  *
  * Tools:
- *   mem_save   — Save a memory
- *   mem_search — Search (keyword + optional vector)
- *   mem_get    — Fetch by IDs
- *   mem_list   — Recent memories
+ *   mem_save    - Save a memory (with optional tags)
+ *   mem_search  - Search (keyword + optional vector)
+ *   mem_get     - Fetch by IDs (full content)
+ *   mem_list    - Recent memories
+ *   mem_update  - Update an existing memory
+ *   mem_delete  - Delete memories by IDs
+ *   mem_tags    - List all tags (with counts)
  */
 export {};

package/dist/index.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 /**
- * mcp-simple-memory — Persistent memory for Claude Code
+ * mcp-simple-memory - Persistent memory for Claude Code
  *
- * ~450 lines. SQLite (sql.js WASM, zero native deps).
+ * SQLite (sql.js WASM, zero native deps).
  * Optional Gemini semantic search. Works on Windows/Mac/Linux.
  *
  * Tools:
- *   mem_save   — Save a memory
- *   mem_search — Search (keyword + optional vector)
- *   mem_get    — Fetch by IDs
- *   mem_list   — Recent memories
+ *   mem_save    - Save a memory (with optional tags)
+ *   mem_search  - Search (keyword + optional vector)
+ *   mem_get     - Fetch by IDs (full content)
+ *   mem_list    - Recent memories
+ *   mem_update  - Update an existing memory
+ *   mem_delete  - Delete memories by IDs
+ *   mem_tags    - List all tags (with counts)
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -18,7 +21,7 @@ import initSqlJs from "sql.js";
 import { join } from "path";
 import { mkdirSync, existsSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-// ─── Config ────────────────────────────────────────────────────
+// ---- Config ---------------------------------------------------------------
 const DATA_DIR = process.env.MCP_MEMORY_DIR || join(homedir(), ".mcp-simple-memory");
 const DB_PATH = join(DATA_DIR, "memory.db");
 const GEMINI_API_KEY = process.env.GEMINI_API_KEY || "";
@@ -27,7 +30,7 @@ const EMBEDDING_DIMS = 3072;
 if (!existsSync(DATA_DIR)) {
     mkdirSync(DATA_DIR, { recursive: true });
 }
-// ─── Database ──────────────────────────────────────────────────
+// ---- Database -------------------------------------------------------------
 let db;
 async function initDb() {
     const SQL = await initSqlJs();
@@ -45,7 +48,9 @@ async function initDb() {
       type TEXT DEFAULT 'memory',
       project TEXT DEFAULT 'default',
       created_at INTEGER NOT NULL,
-      created_iso TEXT NOT NULL
+      created_iso TEXT NOT NULL,
+      updated_at INTEGER,
+      updated_iso TEXT
     );
   `);
     db.run(`
@@ -53,16 +58,40 @@ async function initDb() {
       memory_id INTEGER PRIMARY KEY,
       vector BLOB NOT NULL
     );
+  `);
+    db.run(`
+    CREATE TABLE IF NOT EXISTS tags (
+      memory_id INTEGER NOT NULL,
+      tag TEXT NOT NULL,
+      PRIMARY KEY (memory_id, tag)
+    );
   `);
     db.run(`CREATE INDEX IF NOT EXISTS idx_mem_project ON memories(project);`);
     db.run(`CREATE INDEX IF NOT EXISTS idx_mem_created ON memories(created_at);`);
     db.run(`CREATE INDEX IF NOT EXISTS idx_mem_type ON memories(type);`);
+    db.run(`CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag);`);
+    // Migration: add updated_at/updated_iso columns if missing
+    try {
+        db.run(`SELECT updated_at FROM memories LIMIT 1`);
+    }
+    catch {
+        try {
+            db.run(`ALTER TABLE memories ADD COLUMN updated_at INTEGER`);
+        }
+        catch { /* already exists */ }
+        try {
+            db.run(`ALTER TABLE memories ADD COLUMN updated_iso TEXT`);
+        }
+        catch { /* already exists */ }
+    }
+    // Migration: create tags table if missing (for upgrades from 0.1.x)
+    // Already handled by CREATE TABLE IF NOT EXISTS above
     persist();
 }
 function persist() {
     writeFileSync(DB_PATH, Buffer.from(db.export()));
 }
-// ─── Query helper ──────────────────────────────────────────────
+// ---- Query helper ---------------------------------------------------------
 function queryAll(sql, params = []) {
     const stmt = db.prepare(sql);
     if (params.length)
@@ -73,12 +102,35 @@ function queryAll(sql, params = []) {
     stmt.free();
     return rows;
 }
+function runSql(sql, params = []) {
+    db.run(sql, params);
+}
 function getByIds(ids) {
     if (!ids.length)
         return [];
-    return queryAll(`SELECT * FROM memories WHERE id IN (${ids.map(() => "?").join(",")})`, ids);
+    const rows = queryAll(`SELECT * FROM memories WHERE id IN (${ids.map(() => "?").join(",")})`, ids);
+    // Attach tags to each row
+    for (const row of rows) {
+        row.tags = getTagsForMemory(row.id);
+    }
+    return rows;
+}
+function getTagsForMemory(memoryId) {
+    return queryAll(`SELECT tag FROM tags WHERE memory_id = ?`, [memoryId]).map((r) => r.tag);
+}
+function setTagsForMemory(memoryId, tags) {
+    runSql(`DELETE FROM tags WHERE memory_id = ?`, [memoryId]);
+    for (const tag of tags) {
+        const normalized = tag.trim().toLowerCase();
+        if (normalized) {
+            runSql(`INSERT OR IGNORE INTO tags (memory_id, tag) VALUES (?, ?)`, [
+                memoryId,
+                normalized,
+            ]);
+        }
+    }
 }
-// ─── Gemini Embeddings ─────────────────────────────────────────
+// ---- Gemini Embeddings ----------------------------------------------------
 async function getEmbedding(text) {
     if (!GEMINI_API_KEY)
         return null;
@@ -107,7 +159,8 @@ function cosine(a, b) {
         nA += a[i] * a[i];
         nB += b[i] * b[i];
     }
-    return dot / (Math.sqrt(nA) * Math.sqrt(nB));
+    const denom = Math.sqrt(nA) * Math.sqrt(nB);
+    return denom === 0 ? 0 : dot / denom;
 }
 async function vectorSearch(query, limit, project) {
     const qVec = await getEmbedding(query);
@@ -125,7 +178,7 @@ async function vectorSearch(query, limit, project) {
     scored.sort((a, b) => b.score - a.score);
     return scored.slice(0, limit);
 }
-// ─── Response helpers ──────────────────────────────────────────
+// ---- Response helpers -----------------------------------------------------
 function ok(text) {
     return { content: [{ type: "text", text }] };
 }
@@ -137,11 +190,13 @@ function formatRows(rows, header) {
         return ok(`${header}\n\n(no results)`);
     const lines = rows.map((r) => {
         const preview = (r.content || "").substring(0, 150).replace(/\n/g, " ");
-        return `#${r.id} | ${r.type} | ${r.project} | ${r.created_iso}\n  ${r.title || "(no title)"}\n  ${preview}`;
+        const tags = r.tags?.length ? ` [${r.tags.join(", ")}]` : "";
+        const updated = r.updated_iso ? ` (updated: ${r.updated_iso})` : "";
+        return `#${r.id} | ${r.type} | ${r.project} | ${r.created_iso}${updated}\n  ${r.title || "(no title)"}${tags}\n  ${preview}`;
     });
     return ok(`# ${header} (${rows.length})\n\n${lines.join("\n\n")}`);
 }
-// ─── Tool Handlers ─────────────────────────────────────────────
+// ---- Tool Handlers --------------------------------------------------------
 async function handleSave(args) {
     const content = args.text || args.content;
     if (!content)
@@ -150,34 +205,73 @@ async function handleSave(args) {
     const title = args.title || content.substring(0, 80);
     const project = args.project || "default";
     const type = args.type || "memory";
-    db.run(`INSERT INTO memories (title, content, type, project, created_at, created_iso) VALUES (?, ?, ?, ?, ?, ?)`, [title, content, type, project, now, new Date(now).toISOString()]);
+    runSql(`INSERT INTO memories (title, content, type, project, created_at, created_iso) VALUES (?, ?, ?, ?, ?, ?)`, [title, content, type, project, now, new Date(now).toISOString()]);
     const id = queryAll(`SELECT last_insert_rowid() as id`)[0]?.id ?? 0;
+    // Tags
+    const tags = args.tags || [];
+    if (tags.length) {
+        setTagsForMemory(id, tags);
+    }
     persist();
-    // Background embedding
+    // Background embedding (fire-and-forget)
     if (GEMINI_API_KEY) {
         getEmbedding(`${title}\n${content}`).then((vec) => {
             if (vec) {
-                db.run(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [
-                    id,
-                    vec.buffer,
-                ]);
+                runSql(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [id, vec.buffer]);
                 persist();
             }
         });
     }
-    return ok(`Saved memory #${id} (project: ${project})`);
+    const tagStr = tags.length ? ` tags: [${tags.join(", ")}]` : "";
+    return ok(`Saved memory #${id} (project: ${project})${tagStr}`);
 }
 async function handleSearch(args) {
     const query = args.query;
     const limit = args.limit || 20;
     const project = args.project;
     const mode = args.mode || "auto";
-    // No query → return recent
+    const tag = args.tag;
+    const type = args.type;
+    // Tag-only search
+    if (tag && !query) {
+        let sql = `SELECT m.* FROM memories m JOIN tags t ON m.id = t.memory_id WHERE t.tag = ?`;
+        const params = [tag.toLowerCase()];
+        if (project) {
+            sql += ` AND m.project = ?`;
+            params.push(project);
+        }
+        if (type) {
+            sql += ` AND m.type = ?`;
+            params.push(type);
+        }
+        sql += ` ORDER BY m.created_at DESC LIMIT ?`;
+        params.push(limit);
+        const rows = queryAll(sql, params);
+        for (const row of rows)
+            row.tags = getTagsForMemory(row.id);
+        return formatRows(rows, `Tag: "${tag}"`);
+    }
+    // No query -> return recent
     if (!query) {
-        const sql = project
-            ? `SELECT * FROM memories WHERE project = ? ORDER BY created_at DESC LIMIT ?`
-            : `SELECT * FROM memories ORDER BY created_at DESC LIMIT ?`;
-        return formatRows(queryAll(sql, project ? [project, limit] : [limit]), "Recent memories");
+        let sql = `SELECT * FROM memories`;
+        const params = [];
+        const conds = [];
+        if (project) {
+            conds.push(`project = ?`);
+            params.push(project);
+        }
+        if (type) {
+            conds.push(`type = ?`);
+            params.push(type);
+        }
+        if (conds.length)
+            sql += ` WHERE ${conds.join(" AND ")}`;
+        sql += ` ORDER BY created_at DESC LIMIT ?`;
+        params.push(limit);
+        const rows = queryAll(sql, params);
+        for (const row of rows)
+            row.tags = getTagsForMemory(row.id);
+        return formatRows(rows, "Recent memories");
     }
     let kwResults = [];
     let vecResults = [];
@@ -185,29 +279,48 @@ async function handleSearch(args) {
     if (mode === "fts" || mode === "keyword" || mode === "auto") {
         const words = query.split(/\s+/).filter((w) => w.length > 0);
         if (words.length) {
-            const conds = words.map(() => `(title LIKE ? OR content LIKE ?)`).join(" OR ");
+            const wordConds = words
+                .map(() => `(m.title LIKE ? OR m.content LIKE ?)`)
+                .join(" OR ");
             const params = [];
             for (const w of words) {
                 params.push(`%${w}%`, `%${w}%`);
             }
-            let sql = `SELECT * FROM memories WHERE (${conds})`;
+            let sql = `SELECT DISTINCT m.* FROM memories m`;
+            if (tag) {
+                sql += ` JOIN tags t ON m.id = t.memory_id`;
+            }
+            sql += ` WHERE (${wordConds})`;
+            if (tag) {
+                sql += ` AND t.tag = ?`;
+                params.push(tag.toLowerCase());
+            }
             if (project) {
-                sql += ` AND project = ?`;
+                sql += ` AND m.project = ?`;
                 params.push(project);
             }
-            sql += ` ORDER BY created_at DESC LIMIT ?`;
+            if (type) {
+                sql += ` AND m.type = ?`;
+                params.push(type);
+            }
+            sql += ` ORDER BY m.created_at DESC LIMIT ?`;
             params.push(limit);
             kwResults = queryAll(sql, params);
+            for (const row of kwResults)
+                row.tags = getTagsForMemory(row.id);
         }
     }
     // Vector search (if keyword found few results)
-    if ((mode === "vector" || (mode === "auto" && kwResults.length < 3)) && GEMINI_API_KEY) {
+    if ((mode === "vector" || (mode === "auto" && kwResults.length < 3)) &&
+        GEMINI_API_KEY) {
         vecResults = await vectorSearch(query, limit, project);
     }
     // Merge
     if (vecResults.length && kwResults.length) {
         const kwIds = new Set(kwResults.map((r) => r.id));
-        const extra = vecResults.filter((r) => !kwIds.has(r.id)).map((r) => r.id);
+        const extra = vecResults
+            .filter((r) => !kwIds.has(r.id))
+            .map((r) => r.id);
         if (extra.length)
             kwResults = [...kwResults, ...getByIds(extra)];
         return formatRows(kwResults.slice(0, limit), `Search: "${query}" (Keyword+Vector)`);
@@ -226,38 +339,177 @@ async function handleGet(args) {
 async function handleList(args) {
     const limit = args.limit || 20;
     const project = args.project;
-    const sql = project
-        ? `SELECT * FROM memories WHERE project = ? ORDER BY created_at DESC LIMIT ?`
-        : `SELECT * FROM memories ORDER BY created_at DESC LIMIT ?`;
-    return formatRows(queryAll(sql, project ? [project, limit] : [limit]), "Memories");
+    const type = args.type;
+    const tag = args.tag;
+    if (tag) {
+        let sql = `SELECT m.* FROM memories m JOIN tags t ON m.id = t.memory_id WHERE t.tag = ?`;
+        const params = [tag.toLowerCase()];
+        if (project) {
+            sql += ` AND m.project = ?`;
+            params.push(project);
+        }
+        if (type) {
+            sql += ` AND m.type = ?`;
+            params.push(type);
+        }
+        sql += ` ORDER BY m.created_at DESC LIMIT ?`;
+        params.push(limit);
+        const rows = queryAll(sql, params);
+        for (const row of rows)
+            row.tags = getTagsForMemory(row.id);
+        return formatRows(rows, `Memories (tag: ${tag})`);
+    }
+    let sql = `SELECT * FROM memories`;
+    const params = [];
+    const conds = [];
+    if (project) {
+        conds.push(`project = ?`);
+        params.push(project);
+    }
+    if (type) {
+        conds.push(`type = ?`);
+        params.push(type);
+    }
+    if (conds.length)
+        sql += ` WHERE ${conds.join(" AND ")}`;
+    sql += ` ORDER BY created_at DESC LIMIT ?`;
+    params.push(limit);
+    const rows = queryAll(sql, params);
+    for (const row of rows)
+        row.tags = getTagsForMemory(row.id);
+    return formatRows(rows, "Memories");
+}
+async function handleUpdate(args) {
+    const id = args.id;
+    if (!id)
+        return err("id is required");
+    const existing = getByIds([id]);
+    if (!existing.length)
+        return err(`Memory #${id} not found`);
+    const now = Date.now();
+    const updates = [];
+    const params = [];
+    if (args.text !== undefined || args.content !== undefined) {
+        updates.push(`content = ?`);
+        params.push(args.text || args.content);
+    }
+    if (args.title !== undefined) {
+        updates.push(`title = ?`);
+        params.push(args.title);
+    }
+    if (args.type !== undefined) {
+        updates.push(`type = ?`);
+        params.push(args.type);
+    }
+    if (args.project !== undefined) {
+        updates.push(`project = ?`);
+        params.push(args.project);
+    }
+    if (!updates.length && !args.tags) {
+        return err("Nothing to update. Provide text, title, type, project, or tags.");
+    }
+    if (updates.length) {
+        updates.push(`updated_at = ?`, `updated_iso = ?`);
+        params.push(now, new Date(now).toISOString());
+        params.push(id);
+        runSql(`UPDATE memories SET ${updates.join(", ")} WHERE id = ?`, params);
+    }
+    // Update tags if provided
+    if (args.tags !== undefined) {
+        setTagsForMemory(id, args.tags || []);
+    }
+    persist();
+    // Re-embed if content changed
+    if ((args.text || args.content) && GEMINI_API_KEY) {
+        const newContent = args.text || args.content;
+        const newTitle = args.title || existing[0].title;
+        getEmbedding(`${newTitle}\n${newContent}`).then((vec) => {
+            if (vec) {
+                runSql(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [id, vec.buffer]);
+                persist();
+            }
+        });
+    }
+    return ok(`Updated memory #${id}`);
+}
+async function handleDelete(args) {
+    const ids = args.ids;
+    if (!ids?.length)
+        return err("ids array is required");
+    const existing = getByIds(ids);
+    if (!existing.length)
+        return err("No matching memories found");
+    const placeholders = ids.map(() => "?").join(",");
+    runSql(`DELETE FROM memories WHERE id IN (${placeholders})`, ids);
+    runSql(`DELETE FROM embeddings WHERE memory_id IN (${placeholders})`, ids);
+    runSql(`DELETE FROM tags WHERE memory_id IN (${placeholders})`, ids);
+    persist();
+    return ok(`Deleted ${existing.length} memor${existing.length === 1 ? "y" : "ies"}: ${existing.map((r) => `#${r.id}`).join(", ")}`);
+}
+async function handleTags(args) {
+    const project = args.project;
+    let sql = `SELECT t.tag, COUNT(*) as count FROM tags t`;
+    const params = [];
+    if (project) {
+        sql += ` JOIN memories m ON m.id = t.memory_id WHERE m.project = ?`;
+        params.push(project);
+    }
+    sql += ` GROUP BY t.tag ORDER BY count DESC`;
+    const rows = queryAll(sql, params);
+    if (!rows.length)
+        return ok("No tags found.");
+    const lines = rows.map((r) => `  ${r.tag} (${r.count})`);
+    return ok(`# Tags (${rows.length})\n\n${lines.join("\n")}`);
 }
-// ─── MCP Server ────────────────────────────────────────────────
-const server = new Server({ name: "mcp-simple-memory", version: "0.1.0" }, { capabilities: { tools: {} } });
+// ---- MCP Server -----------------------------------------------------------
+const server = new Server({ name: "mcp-simple-memory", version: "0.2.0" }, { capabilities: { tools: {} } });
 const tools = [
     {
         name: "mem_save",
-        description: "Save a memory. Params: text (required), title, project, type (memory/decision/error/session_summary)",
+        description: "Save a memory with optional tags. Params: text (required), title, project, type, tags[]",
         inputSchema: {
             type: "object",
             properties: {
                 text: { type: "string", description: "Content to save" },
-                title: { type: "string", description: "Short title (auto-generated if omitted)" },
-                project: { type: "string", description: "Project name (default: 'default')" },
-                type: { type: "string", description: "Type: memory, decision, error, session_summary" },
+                title: {
+                    type: "string",
+                    description: "Short title (auto-generated if omitted)",
+                },
+                project: {
+                    type: "string",
+                    description: "Project name (default: 'default')",
+                },
+                type: {
+                    type: "string",
+                    description: "Type: memory, decision, error, session_summary, todo, snippet",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Tags for categorization (e.g. ['bug', 'auth'])",
+                },
             },
             required: ["text"],
         },
     },
     {
         name: "mem_search",
-        description: "Search memories by keyword or meaning. Params: query, limit, project, mode (keyword/vector/auto)",
+        description: "Search memories by keyword, meaning, tag, or type. Params: query, limit, project, mode, tag, type",
         inputSchema: {
             type: "object",
             properties: {
-                query: { type: "string", description: "Search query (omit for recent)" },
+                query: {
+                    type: "string",
+                    description: "Search query (omit for recent)",
+                },
                 limit: { type: "number", description: "Max results (default: 20)" },
                 project: { type: "string", description: "Filter by project" },
-                mode: { type: "string", description: "keyword, vector, or auto (default: auto)" },
+                mode: {
+                    type: "string",
+                    description: "keyword, vector, or auto (default: auto)",
+                },
+                tag: { type: "string", description: "Filter by tag" },
+                type: { type: "string", description: "Filter by type" },
             },
         },
     },
@@ -267,19 +519,70 @@ const tools = [
         inputSchema: {
             type: "object",
             properties: {
-                ids: { type: "array", items: { type: "number" }, description: "Memory IDs to fetch" },
+                ids: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Memory IDs to fetch",
+                },
             },
             required: ["ids"],
         },
     },
     {
         name: "mem_list",
-        description: "List recent memories. Params: limit, project",
+        description: "List recent memories. Filter by project, type, or tag.",
         inputSchema: {
             type: "object",
             properties: {
                 limit: { type: "number", description: "Max results (default: 20)" },
                 project: { type: "string", description: "Filter by project" },
+                type: { type: "string", description: "Filter by type" },
+                tag: { type: "string", description: "Filter by tag" },
+            },
+        },
+    },
+    {
+        name: "mem_update",
+        description: "Update an existing memory. Params: id (required), text, title, type, project, tags[]",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "number", description: "Memory ID to update" },
+                text: { type: "string", description: "New content" },
+                title: { type: "string", description: "New title" },
+                type: { type: "string", description: "New type" },
+                project: { type: "string", description: "New project" },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Replace all tags (pass [] to clear)",
+                },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "mem_delete",
+        description: "Delete memories by IDs. Also removes embeddings and tags.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ids: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Memory IDs to delete",
+                },
+            },
+            required: ["ids"],
+        },
+    },
+    {
+        name: "mem_tags",
+        description: "List all tags with their usage counts. Optionally filter by project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                project: { type: "string", description: "Filter by project" },
             },
         },
     },
@@ -289,9 +592,16 @@ const handlers = {
     mem_search: handleSearch,
     mem_get: handleGet,
     mem_list: handleList,
+    mem_update: handleUpdate,
+    mem_delete: handleDelete,
+    mem_tags: handleTags,
 };
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: tools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
+    tools: tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+    })),
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const handler = handlers[request.params.name];
@@ -304,13 +614,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return err(`Error: ${error instanceof Error ? error.message : String(error)}`);
     }
 });
-// ─── Start ─────────────────────────────────────────────────────
+// ---- Start ----------------------------------------------------------------
 console.log = console.error; // MCP uses stdout for JSON-RPC
 async function main() {
     await initDb();
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`[mcp-simple-memory] DB: ${DB_PATH} | Embeddings: ${GEMINI_API_KEY ? "ON" : "OFF"}`);
+    console.error(`[mcp-simple-memory] v0.2.0 | DB: ${DB_PATH} | Embeddings: ${GEMINI_API_KEY ? "ON" : "OFF"}`);
 }
 main().catch((e) => {
     console.error(`[mcp-simple-memory] Fatal: ${e}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-simple-memory",
-  "version": "0.1.0",
-  "description": "Simple persistent memory for Claude Code. ~500 lines, SQLite, optional semantic search. Zero native deps.",
+  "version": "0.2.0",
+  "description": "Persistent memory for Claude Code via MCP. SQLite + optional semantic search. Zero native deps. Works on Windows/Mac/Linux.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -10,6 +10,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",
+    "test": "node --import tsx --test test/*.test.ts",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -31,6 +32,7 @@
   "devDependencies": {
     "@types/node": "^22.15.0",
     "@types/sql.js": "^1.4.9",
+    "tsx": "^4.19.0",
     "typescript": "^5.8.3"
   },
   "engines": {