@alejandroroman/agent-kit 0.1.3 → 0.2.0

package/dist/_memory/dist/config.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const MemoryConfigSchema: z.ZodObject<{
+    dbPath: z.ZodDefault<z.ZodString>;
+    embedding: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<{
+            ollama: "ollama";
+            voyage: "voyage";
+        }>>;
+        model: z.ZodDefault<z.ZodString>;
+        endpoint: z.ZodDefault<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;

package/dist/_memory/dist/config.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const MemoryConfigSchema = z.object({
+    dbPath: z.string().default("~/.agent-kit/memory.db"),
+    embedding: z
+        .object({
+        provider: z.enum(["ollama", "voyage"]).default("ollama"),
+        model: z.string().default("all-minilm:l6-v2"),
+        endpoint: z.string().default("http://localhost:11434"),
+        apiKey: z.string().optional(),
+    })
+        .default({
+        provider: "ollama",
+        model: "all-minilm:l6-v2",
+        endpoint: "http://localhost:11434",
+    }),
+});

package/dist/_memory/dist/db/client.d.ts

@@ -0,0 +1,2 @@
+import Database from "better-sqlite3";
+export declare function createDatabase(dbPath: string, dimensions?: number): Database.Database;

package/dist/_memory/dist/db/client.js

@@ -0,0 +1,15 @@
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { SCHEMA_SQL, FTS_SQL, createVecSQL } from "./schema.js";
+export function createDatabase(dbPath, dimensions = 384) {
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    // Load sqlite-vec extension
+    sqliteVec.load(db);
+    // Create tables
+    db.exec(SCHEMA_SQL);
+    db.exec(FTS_SQL);
+    db.exec(createVecSQL(dimensions));
+    return db;
+}

package/dist/_memory/dist/db/schema.d.ts

@@ -0,0 +1,14 @@
+export declare const SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS memories (\n  id TEXT PRIMARY KEY,\n  agent_id TEXT NOT NULL,\n  namespace TEXT NOT NULL,\n  content TEXT NOT NULL,\n  type TEXT NOT NULL CHECK(type IN ('fact', 'preference', 'decision', 'learning', 'observation')),\n  metadata JSON,\n  created_at TEXT NOT NULL DEFAULT (datetime('now')),\n  updated_at TEXT NOT NULL DEFAULT (datetime('now')),\n  deleted_at TEXT\n);\n\nCREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);\nCREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace);\nCREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);\nCREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);\nCREATE INDEX IF NOT EXISTS idx_memories_active ON memories(deleted_at) WHERE deleted_at IS NULL;\n";
+export declare const FTS_SQL = "\nCREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(\n  content, type, namespace, agent_id,\n  content='memories', content_rowid='rowid'\n);\n\nCREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN\n  INSERT INTO memories_fts(rowid, content, type, namespace, agent_id)\n  VALUES (new.rowid, new.content, new.type, new.namespace, new.agent_id);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN\n  INSERT INTO memories_fts(memories_fts, rowid, content, type, namespace, agent_id)\n  VALUES ('delete', old.rowid, old.content, old.type, old.namespace, old.agent_id);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN\n  INSERT INTO memories_fts(memories_fts, rowid, content, type, namespace, agent_id)\n  VALUES ('delete', old.rowid, old.content, old.type, old.namespace, old.agent_id);\n  INSERT INTO memories_fts(rowid, content, type, namespace, agent_id)\n  VALUES (new.rowid, new.content, new.type, new.namespace, new.agent_id);\nEND;\n";
+export declare function createVecSQL(dimensions: number): string;
+export interface MemoryRow {
+    id: string;
+    agent_id: string;
+    namespace: string;
+    content: string;
+    type: "fact" | "preference" | "decision" | "learning" | "observation";
+    metadata: string | null;
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+}

package/dist/_memory/dist/db/schema.js

@@ -0,0 +1,51 @@
+export const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS memories (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  namespace TEXT NOT NULL,
+  content TEXT NOT NULL,
+  type TEXT NOT NULL CHECK(type IN ('fact', 'preference', 'decision', 'learning', 'observation')),
+  metadata JSON,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  deleted_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace);
+CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);
+CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(deleted_at) WHERE deleted_at IS NULL;
+`;
+// FTS5 and vec0 tables are created separately because they need extensions loaded first
+export const FTS_SQL = `
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  content, type, namespace, agent_id,
+  content='memories', content_rowid='rowid'
+);
+
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, content, type, namespace, agent_id)
+  VALUES (new.rowid, new.content, new.type, new.namespace, new.agent_id);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, type, namespace, agent_id)
+  VALUES ('delete', old.rowid, old.content, old.type, old.namespace, old.agent_id);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, type, namespace, agent_id)
+  VALUES ('delete', old.rowid, old.content, old.type, old.namespace, old.agent_id);
+  INSERT INTO memories_fts(rowid, content, type, namespace, agent_id)
+  VALUES (new.rowid, new.content, new.type, new.namespace, new.agent_id);
+END;
+`;
+export function createVecSQL(dimensions) {
+    return `
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec USING vec0(
+  id TEXT PRIMARY KEY,
+  embedding float[${dimensions}]
+);
+`;
+}

package/dist/_memory/dist/embeddings/ollama.d.ts

@@ -0,0 +1,12 @@
+import type { EmbeddingProvider } from "./provider.js";
+export interface OllamaConfig {
+    endpoint: string;
+    model: string;
+}
+export declare class OllamaEmbeddingProvider implements EmbeddingProvider {
+    readonly dimensions = 384;
+    private endpoint;
+    private model;
+    constructor(config: OllamaConfig);
+    embed(text: string): Promise<number[]>;
+}

package/dist/_memory/dist/embeddings/ollama.js

@@ -0,0 +1,22 @@
+export class OllamaEmbeddingProvider {
+    dimensions = 384;
+    endpoint;
+    model;
+    constructor(config) {
+        this.endpoint = config.endpoint;
+        this.model = config.model;
+    }
+    async embed(text) {
+        const response = await fetch(`${this.endpoint}/api/embed`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: this.model, input: text }),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Ollama embedding failed (${response.status}): ${body}`);
+        }
+        const data = await response.json();
+        return data.embeddings[0];
+    }
+}

package/dist/_memory/dist/embeddings/provider.d.ts

@@ -0,0 +1,4 @@
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+    readonly dimensions: number;
+}

package/dist/_memory/dist/embeddings/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/_memory/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createMemoryServer } from "./server.js";
+export { MemoryStore } from "./store.js";
+export { HybridSearch } from "./search.js";
+export { createDatabase } from "./db/client.js";
+export { OllamaEmbeddingProvider } from "./embeddings/ollama.js";
+export { MemoryConfigSchema } from "./config.js";
+export type { EmbeddingProvider } from "./embeddings/provider.js";
+export type { Memory, StoreInput, UpdateInput, ListOptions } from "./store.js";
+export type { SearchOptions, SearchResult } from "./search.js";
+export type { MemoryConfig } from "./config.js";

package/dist/_memory/dist/index.js

@@ -0,0 +1,6 @@
+export { createMemoryServer } from "./server.js";
+export { MemoryStore } from "./store.js";
+export { HybridSearch } from "./search.js";
+export { createDatabase } from "./db/client.js";
+export { OllamaEmbeddingProvider } from "./embeddings/ollama.js";
+export { MemoryConfigSchema } from "./config.js";

package/dist/_memory/dist/search.d.ts

@@ -0,0 +1,30 @@
+import type Database from "better-sqlite3";
+import type { EmbeddingProvider } from "./embeddings/provider.js";
+import type { MemoryRow } from "./db/schema.js";
+export interface SearchOptions {
+    query: string;
+    namespace?: string;
+    agent_id?: string;
+    type?: MemoryRow["type"];
+    limit?: number;
+    min_score?: number;
+}
+export interface SearchResult {
+    id: string;
+    content: string;
+    type: string;
+    namespace: string;
+    agent_id: string;
+    score: number;
+    created_at: string;
+}
+export declare class HybridSearch {
+    private db;
+    private embeddings;
+    constructor(db: Database.Database, embeddings: EmbeddingProvider);
+    search(options: SearchOptions): Promise<SearchResult[]>;
+    private semanticSearch;
+    private keywordSearch;
+    private mergeResults;
+    private computeRecency;
+}

package/dist/_memory/dist/search.js

@@ -0,0 +1,121 @@
+const SEMANTIC_WEIGHT = 0.6;
+const KEYWORD_WEIGHT = 0.3;
+const RECENCY_WEIGHT = 0.1;
+const RECENCY_HALF_LIFE_DAYS = 30;
+const DEFAULT_MIN_SCORE = 0.1;
+export class HybridSearch {
+    db;
+    embeddings;
+    constructor(db, embeddings) {
+        this.db = db;
+        this.embeddings = embeddings;
+    }
+    async search(options) {
+        const limit = options.limit ?? 10;
+        const minScore = options.min_score ?? DEFAULT_MIN_SCORE;
+        const queryEmbedding = await this.embeddings.embed(options.query);
+        // 1. Semantic search via sqlite-vec
+        const semanticResults = this.semanticSearch(queryEmbedding, 50);
+        // 2. Keyword search via FTS5
+        const keywordResults = this.keywordSearch(options.query, 50);
+        // 3. Merge and score
+        const merged = this.mergeResults(semanticResults, keywordResults);
+        // 4. Fetch full rows, apply filters, apply recency boost
+        const results = [];
+        for (const { id, score } of merged) {
+            const row = this.db
+                .prepare(`SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`)
+                .get(id);
+            if (!row)
+                continue;
+            if (options.namespace && row.namespace !== options.namespace)
+                continue;
+            if (options.agent_id && row.agent_id !== options.agent_id)
+                continue;
+            if (options.type && row.type !== options.type)
+                continue;
+            const recencyBoost = this.computeRecency(row.created_at);
+            const finalScore = score + RECENCY_WEIGHT * recencyBoost;
+            if (finalScore < minScore)
+                continue;
+            results.push({
+                id: row.id,
+                content: row.content,
+                type: row.type,
+                namespace: row.namespace,
+                agent_id: row.agent_id,
+                score: finalScore,
+                created_at: row.created_at,
+            });
+            if (results.length >= limit)
+                break;
+        }
+        return results.sort((a, b) => b.score - a.score);
+    }
+    semanticSearch(embedding, limit) {
+        const rows = this.db
+            .prepare(`SELECT id, distance FROM memories_vec
+         WHERE embedding MATCH ? ORDER BY distance LIMIT ?`)
+            .all(new Float32Array(embedding), limit);
+        // sqlite-vec returns L2 distance; convert to similarity score [0, 1]
+        const maxDist = Math.max(...rows.map((r) => r.distance), 1);
+        return rows.map((r) => ({
+            id: r.id,
+            score: 1 - r.distance / maxDist,
+        }));
+    }
+    keywordSearch(query, limit) {
+        // Strip quotes, then wrap each term in double quotes to force literal matching
+        // (prevents FTS5 operators like AND, OR, NOT, +, - from being interpreted)
+        const terms = query
+            .replace(/["]/g, "")
+            .split(/\s+/)
+            .filter(Boolean)
+            .map((term) => `"${term}"`)
+            .join(" ");
+        if (!terms)
+            return [];
+        try {
+            const rows = this.db
+                .prepare(`SELECT m.id, rank FROM memories_fts
+           JOIN memories m ON memories_fts.rowid = m.rowid
+           WHERE memories_fts MATCH ?
+           ORDER BY rank LIMIT ?`)
+                .all(terms, limit);
+            // FTS5 rank is negative (lower = better); normalize to [0, 1]
+            const minRank = Math.min(...rows.map((r) => r.rank), -1);
+            return rows.map((r) => ({
+                id: r.id,
+                score: r.rank / minRank, // both negative, so this gives [0, 1]
+            }));
+        }
+        catch {
+            // FTS5 can throw on malformed queries; fall back to empty
+            return [];
+        }
+    }
+    mergeResults(semantic, keyword) {
+        const scores = new Map();
+        for (const { id, score } of semantic) {
+            scores.set(id, { semantic: score, keyword: 0 });
+        }
+        for (const { id, score } of keyword) {
+            const existing = scores.get(id) ?? { semantic: 0, keyword: 0 };
+            existing.keyword = score;
+            scores.set(id, existing);
+        }
+        const merged = [];
+        for (const [id, s] of scores) {
+            merged.push({
+                id,
+                score: SEMANTIC_WEIGHT * s.semantic + KEYWORD_WEIGHT * s.keyword,
+            });
+        }
+        return merged.sort((a, b) => b.score - a.score);
+    }
+    computeRecency(createdAt) {
+        const ageMs = Date.now() - new Date(createdAt).getTime();
+        const ageDays = ageMs / (1000 * 60 * 60 * 24);
+        return Math.exp((-Math.LN2 * ageDays) / RECENCY_HALF_LIFE_DAYS);
+    }
+}

package/dist/_memory/dist/server.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { EmbeddingProvider } from "./embeddings/provider.js";
+interface ServerOptions {
+    dbPath: string;
+    embeddingProvider: EmbeddingProvider;
+}
+export declare function createMemoryServer(options: ServerOptions): McpServer;
+export {};

package/dist/_memory/dist/server.js

@@ -0,0 +1,126 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { createDatabase } from "./db/client.js";
+import { MemoryStore } from "./store.js";
+import { HybridSearch } from "./search.js";
+import { OllamaEmbeddingProvider } from "./embeddings/ollama.js";
+import { MemoryConfigSchema } from "./config.js";
+import * as os from "os";
+import * as path from "path";
+import * as fs from "fs";
+export function createMemoryServer(options) {
+    const resolvedPath = options.dbPath.startsWith("~")
+        ? path.join(os.homedir(), options.dbPath.slice(1))
+        : options.dbPath;
+    const dir = path.dirname(resolvedPath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const db = createDatabase(resolvedPath, options.embeddingProvider.dimensions);
+    const store = new MemoryStore(db, options.embeddingProvider);
+    const search = new HybridSearch(db, options.embeddingProvider);
+    const server = new McpServer({
+        name: "agent-kit-memory",
+        version: "0.1.0",
+    });
+    const MemoryType = z.enum(["fact", "preference", "decision", "learning", "observation"]);
+    server.tool("store_memory", "Store a new memory with automatic embedding for semantic search", {
+        content: z.string().describe("The memory content to store"),
+        type: MemoryType.describe("Memory type: fact, preference, decision, learning, or observation"),
+        namespace: z.string().describe("Scope: e.g. 'global', 'finance', 'dev/agent-kit'"),
+        agent_id: z.string().optional().describe("Who is storing this memory. Defaults to 'unknown'"),
+        metadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe("Optional metadata: { project, confidence, tags, ... }"),
+    }, async (args) => {
+        const result = await store.store({
+            content: args.content,
+            type: args.type,
+            namespace: args.namespace,
+            agent_id: args.agent_id ?? "unknown",
+            metadata: args.metadata,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    server.tool("search_memory", "Search memories using hybrid semantic + keyword matching", {
+        query: z.string().describe("Search query — natural language or keywords"),
+        namespace: z.string().optional().describe("Filter by namespace"),
+        agent_id: z.string().optional().describe("Filter by agent"),
+        type: MemoryType.optional().describe("Filter by memory type"),
+        limit: z.number().optional().describe("Max results (default 10)"),
+        min_score: z.number().optional().describe("Minimum relevance score 0-1 (default 0.1). Filters out noise"),
+    }, async (args) => {
+        const results = await search.search(args);
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    });
+    server.tool("get_memory", "Retrieve a specific memory by its ID", {
+        id: z.string().describe("Memory ID"),
+    }, async (args) => {
+        const memory = await store.get(args.id);
+        if (!memory) {
+            return { content: [{ type: "text", text: "Memory not found" }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(memory, null, 2) }] };
+    });
+    server.tool("update_memory", "Update an existing memory. Re-embeds if content changes", {
+        id: z.string().describe("Memory ID to update"),
+        content: z.string().optional().describe("New content"),
+        type: MemoryType.optional().describe("New type"),
+        metadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe("New metadata (replaces existing)"),
+    }, async (args) => {
+        const { id, ...updates } = args;
+        const result = await store.update(id, updates);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    server.tool("forget_memory", "Soft-delete a memory. It will no longer appear in search results", {
+        id: z.string().describe("Memory ID to forget"),
+    }, async (args) => {
+        const result = await store.forget(args.id);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    server.tool("list_memories", "Browse memories by scope, sorted by most recent first", {
+        namespace: z.string().optional().describe("Filter by namespace"),
+        agent_id: z.string().optional().describe("Filter by agent"),
+        type: MemoryType.optional().describe("Filter by memory type"),
+        limit: z.number().optional().describe("Max results (default 50)"),
+        offset: z.number().optional().describe("Pagination offset"),
+    }, async (args) => {
+        const results = await store.list(args);
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    });
+    return server;
+}
+// CLI entry point
+async function main() {
+    const config = MemoryConfigSchema.parse({
+        dbPath: process.env.MEMORY_DB_PATH,
+        embedding: {
+            provider: process.env.MEMORY_EMBEDDING_PROVIDER,
+            model: process.env.MEMORY_EMBEDDING_MODEL,
+            endpoint: process.env.MEMORY_EMBEDDING_ENDPOINT,
+            apiKey: process.env.MEMORY_EMBEDDING_API_KEY,
+        },
+    });
+    const embeddingProvider = new OllamaEmbeddingProvider({
+        endpoint: config.embedding.endpoint,
+        model: config.embedding.model,
+    });
+    const server = createMemoryServer({
+        dbPath: config.dbPath,
+        embeddingProvider,
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+// Run if executed directly
+const isMain = process.argv[1]?.endsWith("server.ts") || process.argv[1]?.endsWith("server.js");
+if (isMain) {
+    main().catch((err) => {
+        console.error("Memory server failed to start:", err);
+        process.exit(1);
+    });
+}

package/dist/_memory/dist/store.d.ts

@@ -0,0 +1,51 @@
+import type Database from "better-sqlite3";
+import type { EmbeddingProvider } from "./embeddings/provider.js";
+import type { MemoryRow } from "./db/schema.js";
+export interface StoreInput {
+    content: string;
+    type: MemoryRow["type"];
+    namespace: string;
+    agent_id: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateInput {
+    content?: string;
+    type?: MemoryRow["type"];
+    metadata?: Record<string, unknown>;
+}
+export interface ListOptions {
+    namespace?: string;
+    agent_id?: string;
+    type?: MemoryRow["type"];
+    limit?: number;
+    offset?: number;
+}
+export interface Memory {
+    id: string;
+    agent_id: string;
+    namespace: string;
+    content: string;
+    type: MemoryRow["type"];
+    metadata: Record<string, unknown> | null;
+    created_at: string;
+    updated_at: string;
+}
+export declare class MemoryStore {
+    private db;
+    private embeddings;
+    constructor(db: Database.Database, embeddings: EmbeddingProvider);
+    store(input: StoreInput): Promise<{
+        id: string;
+        created_at: string;
+    }>;
+    get(id: string): Promise<Memory | null>;
+    update(id: string, input: UpdateInput): Promise<{
+        id: string;
+        updated_at: string;
+    }>;
+    forget(id: string): Promise<{
+        success: boolean;
+    }>;
+    list(options?: ListOptions): Promise<Memory[]>;
+    private rowToMemory;
+}

package/dist/_memory/dist/store.js

@@ -0,0 +1,115 @@
+import { nanoid } from "nanoid";
+export class MemoryStore {
+    db;
+    embeddings;
+    constructor(db, embeddings) {
+        this.db = db;
+        this.embeddings = embeddings;
+    }
+    async store(input) {
+        const id = nanoid();
+        const now = new Date().toISOString();
+        const metadataJson = input.metadata ? JSON.stringify(input.metadata) : null;
+        const embedding = await this.embeddings.embed(input.content);
+        const insertTxn = this.db.transaction(() => {
+            this.db
+                .prepare(`INSERT INTO memories (id, agent_id, namespace, content, type, metadata, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(id, input.agent_id, input.namespace, input.content, input.type, metadataJson, now, now);
+            this.db
+                .prepare(`INSERT INTO memories_vec (id, embedding) VALUES (?, ?)`)
+                .run(id, new Float32Array(embedding));
+        });
+        insertTxn();
+        return { id, created_at: now };
+    }
+    async get(id) {
+        const row = this.db
+            .prepare(`SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`)
+            .get(id);
+        if (!row)
+            return null;
+        return this.rowToMemory(row);
+    }
+    async update(id, input) {
+        const now = new Date().toISOString();
+        const sets = [`updated_at = ?`];
+        const values = [now];
+        if (input.content !== undefined) {
+            sets.push(`content = ?`);
+            values.push(input.content);
+        }
+        if (input.type !== undefined) {
+            sets.push(`type = ?`);
+            values.push(input.type);
+        }
+        if (input.metadata !== undefined) {
+            sets.push(`metadata = ?`);
+            values.push(JSON.stringify(input.metadata));
+        }
+        values.push(id);
+        if (input.content !== undefined) {
+            const embedding = await this.embeddings.embed(input.content);
+            const updateTxn = this.db.transaction(() => {
+                this.db.prepare(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+                this.db.prepare(`DELETE FROM memories_vec WHERE id = ?`).run(id);
+                this.db
+                    .prepare(`INSERT INTO memories_vec (id, embedding) VALUES (?, ?)`)
+                    .run(id, new Float32Array(embedding));
+            });
+            updateTxn();
+        }
+        else {
+            this.db.prepare(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+        }
+        return { id, updated_at: now };
+    }
+    async forget(id) {
+        const forgetTxn = this.db.transaction(() => {
+            const result = this.db
+                .prepare(`UPDATE memories SET deleted_at = datetime('now') WHERE id = ? AND deleted_at IS NULL`)
+                .run(id);
+            if (result.changes > 0) {
+                this.db.prepare(`DELETE FROM memories_vec WHERE id = ?`).run(id);
+            }
+            return result;
+        });
+        const result = forgetTxn();
+        return { success: result.changes > 0 };
+    }
+    async list(options = {}) {
+        const conditions = [`deleted_at IS NULL`];
+        const values = [];
+        if (options.namespace) {
+            conditions.push(`namespace = ?`);
+            values.push(options.namespace);
+        }
+        if (options.agent_id) {
+            conditions.push(`agent_id = ?`);
+            values.push(options.agent_id);
+        }
+        if (options.type) {
+            conditions.push(`type = ?`);
+            values.push(options.type);
+        }
+        const limit = options.limit ?? 50;
+        const offset = options.offset ?? 0;
+        const rows = this.db
+            .prepare(`SELECT * FROM memories WHERE ${conditions.join(" AND ")}
+         ORDER BY created_at DESC LIMIT ? OFFSET ?`)
+            .all(...values, limit, offset);
+        return rows.map((row) => this.rowToMemory(row));
+    }
+    rowToMemory(row) {
+        return {
+            id: row.id,
+            agent_id: row.agent_id,
+            namespace: row.namespace,
+            content: row.content,
+            type: row.type,
+            metadata: row.metadata ? JSON.parse(row.metadata) : null,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+        };
+    }
+}