@withone/mem 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Mem Database Schema
+ * https://mem.now
+ *
+ * Two tables:
+ * - mem_records: All memories
+ * - mem_links: Relationships between records
+ */
+export declare const SCHEMA_VERSION = "1.0.0";
+export declare const SCHEMA_SQL = "\n-- =============================================================================\n-- Mem: Memory for AI Agents\n-- https://mem.now\n-- Version: 1.0.0\n-- =============================================================================\n\n-- Enable required extensions\nCREATE EXTENSION IF NOT EXISTS vector;\nCREATE EXTENSION IF NOT EXISTS pg_trgm;\n\n-- =============================================================================\n-- RECORDS: All memories\n-- =============================================================================\n\nCREATE TABLE IF NOT EXISTS mem_records (\n    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n    type TEXT NOT NULL,                    -- user-defined (note, decision, preference, etc.)\n    data JSONB NOT NULL,                   -- flexible structure\n    tags TEXT[],\n    embedding vector(1536),\n    searchable_text TEXT,\n    searchable tsvector GENERATED ALWAYS AS (\n        to_tsvector('english', COALESCE(searchable_text, ''))\n    ) STORED,\n\n    -- Relevance scoring\n    weight INTEGER NOT NULL DEFAULT 5 CHECK (weight BETWEEN 1 AND 10),\n    access_count INTEGER NOT NULL DEFAULT 0,\n    last_accessed_at TIMESTAMPTZ,\n    status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'archived')),\n\n    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()\n);\n\n-- =============================================================================\n-- LINKS: Relationships between records\n-- =============================================================================\n\nCREATE TABLE IF NOT EXISTS mem_links (\n    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n    from_id UUID NOT NULL REFERENCES mem_records(id) ON DELETE CASCADE,\n    to_id UUID NOT NULL REFERENCES mem_records(id) ON DELETE CASCADE,\n    relation TEXT NOT NULL,\n    bidirectional BOOLEAN NOT NULL DEFAULT false,    -- true = traversable both ways\n    metadata JSONB,\n    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),\n    UNIQUE(from_id, to_id, relation)\n);\n\n-- =============================================================================\n-- INDEXES\n-- =============================================================================\n\nCREATE INDEX IF NOT EXISTS idx_mem_records_type ON mem_records(type);\nCREATE INDEX IF NOT EXISTS idx_mem_records_tags ON mem_records USING GIN(tags);\nCREATE INDEX IF NOT EXISTS idx_mem_records_data ON mem_records USING GIN(data);\nCREATE INDEX IF NOT EXISTS idx_mem_records_searchable ON mem_records USING GIN(searchable);\nCREATE INDEX IF NOT EXISTS idx_mem_records_status ON mem_records(status);\nCREATE INDEX IF NOT EXISTS idx_mem_records_relevance ON mem_records(\n    status, weight DESC, access_count DESC, last_accessed_at DESC NULLS LAST\n);\n\nCREATE INDEX IF NOT EXISTS idx_mem_links_from ON mem_links(from_id);\nCREATE INDEX IF NOT EXISTS idx_mem_links_to ON mem_links(to_id);\nCREATE INDEX IF NOT EXISTS idx_mem_links_relation ON mem_links(relation);\nCREATE INDEX IF NOT EXISTS idx_mem_links_from_relation ON mem_links(from_id, relation);\nCREATE INDEX IF NOT EXISTS idx_mem_links_to_relation ON mem_links(to_id, relation);\nCREATE INDEX IF NOT EXISTS idx_mem_links_bidirectional ON mem_links(bidirectional) WHERE bidirectional = true;\n\n-- =============================================================================\n-- SCHEMA METADATA\n-- =============================================================================\n\nCREATE TABLE IF NOT EXISTS mem_meta (\n    key TEXT PRIMARY KEY,\n    value TEXT NOT NULL,\n    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()\n);\n\nINSERT INTO mem_meta (key, value) VALUES ('version', '1.0.0')\nON CONFLICT (key) DO UPDATE SET value = '1.0.0', updated_at = NOW();\n";
+export declare const VECTOR_INDEX_SQL = "\nDO $$\nBEGIN\n    IF NOT EXISTS (SELECT 1 FROM pg_indexes WHERE indexname = 'idx_mem_records_embedding') THEN\n        CREATE INDEX idx_mem_records_embedding ON mem_records USING hnsw(embedding vector_cosine_ops);\n    END IF;\nEND $$;\n";
+export declare const FUNCTIONS_SQL = "\n-- =============================================================================\n-- HYBRID SEARCH\n-- Combines semantic similarity with full-text search using RRF\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_hybrid_search(\n    query_text TEXT,\n    query_embedding vector(1536),\n    match_count INT DEFAULT 10,\n    filter_type TEXT DEFAULT NULL,\n    full_text_weight FLOAT DEFAULT 0.3,\n    semantic_weight FLOAT DEFAULT 0.7,\n    rrf_k INT DEFAULT 50,\n    include_archived BOOLEAN DEFAULT FALSE\n)\nRETURNS TABLE (\n    id UUID,\n    type TEXT,\n    data JSONB,\n    tags TEXT[],\n    fts_rank FLOAT,\n    semantic_rank FLOAT,\n    combined_score FLOAT\n)\nLANGUAGE plpgsql\nAS $$\nBEGIN\n    RETURN QUERY\n    WITH fts_results AS (\n        SELECT\n            r.id,\n            ROW_NUMBER() OVER (ORDER BY ts_rank_cd(r.searchable, websearch_to_tsquery('english', query_text)) DESC) AS rank\n        FROM mem_records r\n        WHERE r.searchable @@ websearch_to_tsquery('english', query_text)\n        AND (filter_type IS NULL OR r.type = filter_type)\n        AND (include_archived OR r.status = 'active')\n        LIMIT match_count * 2\n    ),\n    semantic_results AS (\n        SELECT\n            r.id,\n            ROW_NUMBER() OVER (ORDER BY r.embedding <=> query_embedding) AS rank\n        FROM mem_records r\n        WHERE r.embedding IS NOT NULL\n        AND (filter_type IS NULL OR r.type = filter_type)\n        AND (include_archived OR r.status = 'active')\n        ORDER BY r.embedding <=> query_embedding\n        LIMIT match_count * 2\n    ),\n    combined AS (\n        SELECT\n            COALESCE(fts.id, sem.id) AS id,\n            COALESCE(1.0 / (rrf_k + fts.rank), 0.0) AS fts_score,\n            COALESCE(1.0 / (rrf_k + sem.rank), 0.0) AS sem_score\n        FROM fts_results fts\n        FULL OUTER JOIN semantic_results sem ON fts.id = sem.id\n    )\n    SELECT\n        r.id,\n        r.type,\n        r.data,\n        r.tags,\n        c.fts_score::FLOAT AS fts_rank,\n        c.sem_score::FLOAT AS semantic_rank,\n        (c.fts_score * full_text_weight + c.sem_score * semantic_weight)::FLOAT AS combined_score\n    FROM combined c\n    JOIN mem_records r ON r.id = c.id\n    ORDER BY (c.fts_score * full_text_weight + c.sem_score * semantic_weight) DESC\n    LIMIT match_count;\nEND;\n$$;\n\n-- =============================================================================\n-- RELEVANCE SCORING\n-- Combines: weight (40%), access frequency (30%), recency (30%)\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_calculate_relevance(\n    p_weight INTEGER,\n    p_access_count INTEGER,\n    p_last_accessed_at TIMESTAMPTZ,\n    p_created_at TIMESTAMPTZ,\n    max_access_count INTEGER DEFAULT 100\n)\nRETURNS FLOAT\nLANGUAGE plpgsql\nAS $$\nDECLARE\n    weight_score FLOAT;\n    access_score FLOAT;\n    recency_score FLOAT;\n    days_since_access FLOAT;\nBEGIN\n    -- Normalize weight to 0-1 (weight is 1-10)\n    weight_score := (p_weight - 1) / 9.0;\n\n    -- Normalize access count to 0-1 (capped at max_access_count)\n    access_score := LEAST(p_access_count::FLOAT / max_access_count, 1.0);\n\n    -- Calculate recency score (1.0 for today, decays over 30 days to 0.1)\n    IF p_last_accessed_at IS NOT NULL THEN\n        days_since_access := EXTRACT(EPOCH FROM (NOW() - p_last_accessed_at)) / 86400.0;\n        recency_score := GREATEST(1.0 - (days_since_access / 30.0) * 0.9, 0.1);\n    ELSE\n        -- Never accessed, use created_at with lower base score\n        days_since_access := EXTRACT(EPOCH FROM (NOW() - p_created_at)) / 86400.0;\n        recency_score := GREATEST(0.5 - (days_since_access / 60.0) * 0.4, 0.1);\n    END IF;\n\n    -- Combine scores: weight 40%, access 30%, recency 30%\n    RETURN (weight_score * 0.4) + (access_score * 0.3) + (recency_score * 0.3);\nEND;\n$$;\n\n-- =============================================================================\n-- CONTEXT: Get most relevant records for startup\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_get_context(\n    match_count INT DEFAULT 20,\n    filter_types TEXT[] DEFAULT NULL\n)\nRETURNS TABLE (\n    id UUID,\n    type TEXT,\n    data JSONB,\n    tags TEXT[],\n    weight INTEGER,\n    access_count INTEGER,\n    relevance_score FLOAT\n)\nLANGUAGE plpgsql\nAS $$\nBEGIN\n    RETURN QUERY\n    SELECT\n        r.id,\n        r.type,\n        r.data,\n        r.tags,\n        r.weight,\n        r.access_count,\n        mem_calculate_relevance(r.weight, r.access_count, r.last_accessed_at, r.created_at)::FLOAT AS relevance_score\n    FROM mem_records r\n    WHERE r.status = 'active'\n    AND (filter_types IS NULL OR r.type = ANY(filter_types))\n    ORDER BY mem_calculate_relevance(r.weight, r.access_count, r.last_accessed_at, r.created_at) DESC\n    LIMIT match_count;\nEND;\n$$;\n\n-- =============================================================================\n-- ACCESS TRACKING\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_increment_access(record_ids UUID[])\nRETURNS VOID\nLANGUAGE plpgsql\nAS $$\nBEGIN\n    UPDATE mem_records\n    SET\n        access_count = access_count + 1,\n        last_accessed_at = NOW()\n    WHERE id = ANY(record_ids);\nEND;\n$$;\n\n-- =============================================================================\n-- ARCHIVE / UNARCHIVE\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_archive(record_ids UUID[])\nRETURNS INTEGER\nLANGUAGE plpgsql\nAS $$\nDECLARE\n    affected INTEGER;\nBEGIN\n    UPDATE mem_records\n    SET status = 'archived', updated_at = NOW()\n    WHERE id = ANY(record_ids) AND status = 'active';\n    GET DIAGNOSTICS affected = ROW_COUNT;\n    RETURN affected;\nEND;\n$$;\n\nCREATE OR REPLACE FUNCTION mem_unarchive(record_ids UUID[])\nRETURNS INTEGER\nLANGUAGE plpgsql\nAS $$\nDECLARE\n    affected INTEGER;\nBEGIN\n    UPDATE mem_records\n    SET status = 'active', updated_at = NOW()\n    WHERE id = ANY(record_ids) AND status = 'archived';\n    GET DIAGNOSTICS affected = ROW_COUNT;\n    RETURN affected;\nEND;\n$$;\n\n-- =============================================================================\n-- FLUSH: Reset access count\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_flush(record_ids UUID[])\nRETURNS INTEGER\nLANGUAGE plpgsql\nAS $$\nDECLARE\n    affected INTEGER;\nBEGIN\n    UPDATE mem_records\n    SET\n        access_count = 0,\n        last_accessed_at = NULL,\n        updated_at = NOW()\n    WHERE id = ANY(record_ids);\n    GET DIAGNOSTICS affected = ROW_COUNT;\n    RETURN affected;\nEND;\n$$;\n\n-- =============================================================================\n-- GRAPH TRAVERSAL\n-- Respects bidirectional flag\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_get_record_with_links(record_id UUID)\nRETURNS JSONB\nLANGUAGE sql\nAS $$\n    SELECT jsonb_build_object(\n        'id', r.id,\n        'type', r.type,\n        'data', r.data,\n        'tags', r.tags,\n        'weight', r.weight,\n        'access_count', r.access_count,\n        'status', r.status,\n        'created_at', r.created_at,\n        'updated_at', r.updated_at,\n        'outgoing', COALESCE((\n            SELECT jsonb_agg(jsonb_build_object(\n                'relation', l.relation,\n                'bidirectional', l.bidirectional,\n                'metadata', l.metadata,\n                'record', jsonb_build_object(\n                    'id', linked.id,\n                    'type', linked.type,\n                    'data', linked.data\n                )\n            ))\n            FROM mem_links l\n            JOIN mem_records linked ON linked.id = l.to_id\n            WHERE l.from_id = r.id\n        ), '[]'::jsonb),\n        'incoming', COALESCE((\n            SELECT jsonb_agg(jsonb_build_object(\n                'relation', l.relation,\n                'bidirectional', l.bidirectional,\n                'metadata', l.metadata,\n                'record', jsonb_build_object(\n                    'id', linked.id,\n                    'type', linked.type,\n                    'data', linked.data\n                )\n            ))\n            FROM mem_links l\n            JOIN mem_records linked ON linked.id = l.from_id\n            WHERE l.to_id = r.id\n        ), '[]'::jsonb)\n    )\n    FROM mem_records r\n    WHERE r.id = record_id;\n$$;\n\nCREATE OR REPLACE FUNCTION mem_get_linked(\n    record_id UUID,\n    relation_type TEXT DEFAULT NULL,\n    direction TEXT DEFAULT 'outgoing'\n)\nRETURNS TABLE (\n    id UUID,\n    type TEXT,\n    data JSONB,\n    relation TEXT,\n    bidirectional BOOLEAN,\n    link_metadata JSONB\n)\nLANGUAGE sql\nAS $$\n    -- Outgoing links (from this record to others)\n    SELECT\n        r.id,\n        r.type,\n        r.data,\n        l.relation,\n        l.bidirectional,\n        l.metadata\n    FROM mem_links l\n    JOIN mem_records r ON r.id = l.to_id\n    WHERE l.from_id = record_id\n    AND (relation_type IS NULL OR l.relation = relation_type)\n    AND (direction = 'outgoing' OR direction = 'both')\n\n    UNION ALL\n\n    -- Incoming links (from others to this record)\n    -- Only include if bidirectional=true OR direction includes incoming\n    SELECT\n        r.id,\n        r.type,\n        r.data,\n        l.relation,\n        l.bidirectional,\n        l.metadata\n    FROM mem_links l\n    JOIN mem_records r ON r.id = l.from_id\n    WHERE l.to_id = record_id\n    AND (relation_type IS NULL OR l.relation = relation_type)\n    AND (\n        direction = 'incoming'\n        OR direction = 'both'\n        OR l.bidirectional = true\n    );\n$$;\n\n-- =============================================================================\n-- LINK OPERATIONS\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_create_link(\n    from_record_id UUID,\n    to_record_id UUID,\n    relation_type TEXT,\n    is_bidirectional BOOLEAN DEFAULT false,\n    link_metadata JSONB DEFAULT NULL\n)\nRETURNS UUID\nLANGUAGE plpgsql\nAS $$\nDECLARE\n    link_id UUID;\nBEGIN\n    INSERT INTO mem_links (from_id, to_id, relation, bidirectional, metadata)\n    VALUES (from_record_id, to_record_id, relation_type, is_bidirectional, link_metadata)\n    ON CONFLICT (from_id, to_id, relation) DO UPDATE\n    SET bidirectional = is_bidirectional,\n        metadata = COALESCE(link_metadata, mem_links.metadata)\n    RETURNING id INTO link_id;\n    RETURN link_id;\nEND;\n$$;\n\nCREATE OR REPLACE FUNCTION mem_remove_link(\n    from_record_id UUID,\n    to_record_id UUID,\n    relation_type TEXT\n)\nRETURNS BOOLEAN\nLANGUAGE plpgsql\nAS $$\nBEGIN\n    DELETE FROM mem_links\n    WHERE from_id = from_record_id\n    AND to_id = to_record_id\n    AND relation = relation_type;\n    RETURN FOUND;\nEND;\n$$;\n\n-- =============================================================================\n-- TRIGGERS\n-- =============================================================================\n\nCREATE OR REPLACE FUNCTION mem_extract_searchable_text(record_type TEXT, record_data JSONB)\nRETURNS TEXT\nLANGUAGE plpgsql\nAS $$\nBEGIN\n    -- Generic extraction: concatenate all string values\n    RETURN (SELECT string_agg(value::TEXT, ' ')\n            FROM jsonb_each_text(record_data)\n            WHERE value IS NOT NULL AND value != '');\nEND;\n$$;\n\nCREATE OR REPLACE FUNCTION mem_records_trigger()\nRETURNS TRIGGER\nLANGUAGE plpgsql\nAS $$\nBEGIN\n    NEW.searchable_text := mem_extract_searchable_text(NEW.type, NEW.data);\n    NEW.updated_at := NOW();\n    RETURN NEW;\nEND;\n$$;\n\nDROP TRIGGER IF EXISTS mem_records_before_upsert ON mem_records;\nCREATE TRIGGER mem_records_before_upsert\nBEFORE INSERT OR UPDATE ON mem_records\nFOR EACH ROW\nEXECUTE FUNCTION mem_records_trigger();\n";
+export declare function getMigrationSQL(): string;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC,eAAO,MAAM,UAAU,0qHAmFtB,CAAC;AAGF,eAAO,MAAM,gBAAgB,oPAO5B,CAAC;AAEF,eAAO,MAAM,aAAa,k6XAsZzB,CAAC;AAGF,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/schema.js

@@ -0,0 +1,514 @@
+/**
+ * Mem Database Schema
+ * https://mem.now
+ *
+ * Two tables:
+ * - mem_records: All memories
+ * - mem_links: Relationships between records
+ */
+export const SCHEMA_VERSION = "1.0.0";
+export const SCHEMA_SQL = `
+-- =============================================================================
+-- Mem: Memory for AI Agents
+-- https://mem.now
+-- Version: ${SCHEMA_VERSION}
+-- =============================================================================
+
+-- Enable required extensions
+CREATE EXTENSION IF NOT EXISTS vector;
+CREATE EXTENSION IF NOT EXISTS pg_trgm;
+
+-- =============================================================================
+-- RECORDS: All memories
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS mem_records (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    type TEXT NOT NULL,                    -- user-defined (note, decision, preference, etc.)
+    data JSONB NOT NULL,                   -- flexible structure
+    tags TEXT[],
+    embedding vector(1536),
+    searchable_text TEXT,
+    searchable tsvector GENERATED ALWAYS AS (
+        to_tsvector('english', COALESCE(searchable_text, ''))
+    ) STORED,
+
+    -- Relevance scoring
+    weight INTEGER NOT NULL DEFAULT 5 CHECK (weight BETWEEN 1 AND 10),
+    access_count INTEGER NOT NULL DEFAULT 0,
+    last_accessed_at TIMESTAMPTZ,
+    status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'archived')),
+
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- =============================================================================
+-- LINKS: Relationships between records
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS mem_links (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    from_id UUID NOT NULL REFERENCES mem_records(id) ON DELETE CASCADE,
+    to_id UUID NOT NULL REFERENCES mem_records(id) ON DELETE CASCADE,
+    relation TEXT NOT NULL,
+    bidirectional BOOLEAN NOT NULL DEFAULT false,    -- true = traversable both ways
+    metadata JSONB,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(from_id, to_id, relation)
+);
+
+-- =============================================================================
+-- INDEXES
+-- =============================================================================
+
+CREATE INDEX IF NOT EXISTS idx_mem_records_type ON mem_records(type);
+CREATE INDEX IF NOT EXISTS idx_mem_records_tags ON mem_records USING GIN(tags);
+CREATE INDEX IF NOT EXISTS idx_mem_records_data ON mem_records USING GIN(data);
+CREATE INDEX IF NOT EXISTS idx_mem_records_searchable ON mem_records USING GIN(searchable);
+CREATE INDEX IF NOT EXISTS idx_mem_records_status ON mem_records(status);
+CREATE INDEX IF NOT EXISTS idx_mem_records_relevance ON mem_records(
+    status, weight DESC, access_count DESC, last_accessed_at DESC NULLS LAST
+);
+
+CREATE INDEX IF NOT EXISTS idx_mem_links_from ON mem_links(from_id);
+CREATE INDEX IF NOT EXISTS idx_mem_links_to ON mem_links(to_id);
+CREATE INDEX IF NOT EXISTS idx_mem_links_relation ON mem_links(relation);
+CREATE INDEX IF NOT EXISTS idx_mem_links_from_relation ON mem_links(from_id, relation);
+CREATE INDEX IF NOT EXISTS idx_mem_links_to_relation ON mem_links(to_id, relation);
+CREATE INDEX IF NOT EXISTS idx_mem_links_bidirectional ON mem_links(bidirectional) WHERE bidirectional = true;
+
+-- =============================================================================
+-- SCHEMA METADATA
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS mem_meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+INSERT INTO mem_meta (key, value) VALUES ('version', '${SCHEMA_VERSION}')
+ON CONFLICT (key) DO UPDATE SET value = '${SCHEMA_VERSION}', updated_at = NOW();
+`;
+// Vector index (created separately)
+export const VECTOR_INDEX_SQL = `
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM pg_indexes WHERE indexname = 'idx_mem_records_embedding') THEN
+        CREATE INDEX idx_mem_records_embedding ON mem_records USING hnsw(embedding vector_cosine_ops);
+    END IF;
+END $$;
+`;
+export const FUNCTIONS_SQL = `
+-- =============================================================================
+-- HYBRID SEARCH
+-- Combines semantic similarity with full-text search using RRF
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_hybrid_search(
+    query_text TEXT,
+    query_embedding vector(1536),
+    match_count INT DEFAULT 10,
+    filter_type TEXT DEFAULT NULL,
+    full_text_weight FLOAT DEFAULT 0.3,
+    semantic_weight FLOAT DEFAULT 0.7,
+    rrf_k INT DEFAULT 50,
+    include_archived BOOLEAN DEFAULT FALSE
+)
+RETURNS TABLE (
+    id UUID,
+    type TEXT,
+    data JSONB,
+    tags TEXT[],
+    fts_rank FLOAT,
+    semantic_rank FLOAT,
+    combined_score FLOAT
+)
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    RETURN QUERY
+    WITH fts_results AS (
+        SELECT
+            r.id,
+            ROW_NUMBER() OVER (ORDER BY ts_rank_cd(r.searchable, websearch_to_tsquery('english', query_text)) DESC) AS rank
+        FROM mem_records r
+        WHERE r.searchable @@ websearch_to_tsquery('english', query_text)
+        AND (filter_type IS NULL OR r.type = filter_type)
+        AND (include_archived OR r.status = 'active')
+        LIMIT match_count * 2
+    ),
+    semantic_results AS (
+        SELECT
+            r.id,
+            ROW_NUMBER() OVER (ORDER BY r.embedding <=> query_embedding) AS rank
+        FROM mem_records r
+        WHERE r.embedding IS NOT NULL
+        AND (filter_type IS NULL OR r.type = filter_type)
+        AND (include_archived OR r.status = 'active')
+        ORDER BY r.embedding <=> query_embedding
+        LIMIT match_count * 2
+    ),
+    combined AS (
+        SELECT
+            COALESCE(fts.id, sem.id) AS id,
+            COALESCE(1.0 / (rrf_k + fts.rank), 0.0) AS fts_score,
+            COALESCE(1.0 / (rrf_k + sem.rank), 0.0) AS sem_score
+        FROM fts_results fts
+        FULL OUTER JOIN semantic_results sem ON fts.id = sem.id
+    )
+    SELECT
+        r.id,
+        r.type,
+        r.data,
+        r.tags,
+        c.fts_score::FLOAT AS fts_rank,
+        c.sem_score::FLOAT AS semantic_rank,
+        (c.fts_score * full_text_weight + c.sem_score * semantic_weight)::FLOAT AS combined_score
+    FROM combined c
+    JOIN mem_records r ON r.id = c.id
+    ORDER BY (c.fts_score * full_text_weight + c.sem_score * semantic_weight) DESC
+    LIMIT match_count;
+END;
+$$;
+
+-- =============================================================================
+-- RELEVANCE SCORING
+-- Combines: weight (40%), access frequency (30%), recency (30%)
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_calculate_relevance(
+    p_weight INTEGER,
+    p_access_count INTEGER,
+    p_last_accessed_at TIMESTAMPTZ,
+    p_created_at TIMESTAMPTZ,
+    max_access_count INTEGER DEFAULT 100
+)
+RETURNS FLOAT
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    weight_score FLOAT;
+    access_score FLOAT;
+    recency_score FLOAT;
+    days_since_access FLOAT;
+BEGIN
+    -- Normalize weight to 0-1 (weight is 1-10)
+    weight_score := (p_weight - 1) / 9.0;
+
+    -- Normalize access count to 0-1 (capped at max_access_count)
+    access_score := LEAST(p_access_count::FLOAT / max_access_count, 1.0);
+
+    -- Calculate recency score (1.0 for today, decays over 30 days to 0.1)
+    IF p_last_accessed_at IS NOT NULL THEN
+        days_since_access := EXTRACT(EPOCH FROM (NOW() - p_last_accessed_at)) / 86400.0;
+        recency_score := GREATEST(1.0 - (days_since_access / 30.0) * 0.9, 0.1);
+    ELSE
+        -- Never accessed, use created_at with lower base score
+        days_since_access := EXTRACT(EPOCH FROM (NOW() - p_created_at)) / 86400.0;
+        recency_score := GREATEST(0.5 - (days_since_access / 60.0) * 0.4, 0.1);
+    END IF;
+
+    -- Combine scores: weight 40%, access 30%, recency 30%
+    RETURN (weight_score * 0.4) + (access_score * 0.3) + (recency_score * 0.3);
+END;
+$$;
+
+-- =============================================================================
+-- CONTEXT: Get most relevant records for startup
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_get_context(
+    match_count INT DEFAULT 20,
+    filter_types TEXT[] DEFAULT NULL
+)
+RETURNS TABLE (
+    id UUID,
+    type TEXT,
+    data JSONB,
+    tags TEXT[],
+    weight INTEGER,
+    access_count INTEGER,
+    relevance_score FLOAT
+)
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    RETURN QUERY
+    SELECT
+        r.id,
+        r.type,
+        r.data,
+        r.tags,
+        r.weight,
+        r.access_count,
+        mem_calculate_relevance(r.weight, r.access_count, r.last_accessed_at, r.created_at)::FLOAT AS relevance_score
+    FROM mem_records r
+    WHERE r.status = 'active'
+    AND (filter_types IS NULL OR r.type = ANY(filter_types))
+    ORDER BY mem_calculate_relevance(r.weight, r.access_count, r.last_accessed_at, r.created_at) DESC
+    LIMIT match_count;
+END;
+$$;
+
+-- =============================================================================
+-- ACCESS TRACKING
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_increment_access(record_ids UUID[])
+RETURNS VOID
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    UPDATE mem_records
+    SET
+        access_count = access_count + 1,
+        last_accessed_at = NOW()
+    WHERE id = ANY(record_ids);
+END;
+$$;
+
+-- =============================================================================
+-- ARCHIVE / UNARCHIVE
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_archive(record_ids UUID[])
+RETURNS INTEGER
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    affected INTEGER;
+BEGIN
+    UPDATE mem_records
+    SET status = 'archived', updated_at = NOW()
+    WHERE id = ANY(record_ids) AND status = 'active';
+    GET DIAGNOSTICS affected = ROW_COUNT;
+    RETURN affected;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION mem_unarchive(record_ids UUID[])
+RETURNS INTEGER
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    affected INTEGER;
+BEGIN
+    UPDATE mem_records
+    SET status = 'active', updated_at = NOW()
+    WHERE id = ANY(record_ids) AND status = 'archived';
+    GET DIAGNOSTICS affected = ROW_COUNT;
+    RETURN affected;
+END;
+$$;
+
+-- =============================================================================
+-- FLUSH: Reset access count
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_flush(record_ids UUID[])
+RETURNS INTEGER
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    affected INTEGER;
+BEGIN
+    UPDATE mem_records
+    SET
+        access_count = 0,
+        last_accessed_at = NULL,
+        updated_at = NOW()
+    WHERE id = ANY(record_ids);
+    GET DIAGNOSTICS affected = ROW_COUNT;
+    RETURN affected;
+END;
+$$;
+
+-- =============================================================================
+-- GRAPH TRAVERSAL
+-- Respects bidirectional flag
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_get_record_with_links(record_id UUID)
+RETURNS JSONB
+LANGUAGE sql
+AS $$
+    SELECT jsonb_build_object(
+        'id', r.id,
+        'type', r.type,
+        'data', r.data,
+        'tags', r.tags,
+        'weight', r.weight,
+        'access_count', r.access_count,
+        'status', r.status,
+        'created_at', r.created_at,
+        'updated_at', r.updated_at,
+        'outgoing', COALESCE((
+            SELECT jsonb_agg(jsonb_build_object(
+                'relation', l.relation,
+                'bidirectional', l.bidirectional,
+                'metadata', l.metadata,
+                'record', jsonb_build_object(
+                    'id', linked.id,
+                    'type', linked.type,
+                    'data', linked.data
+                )
+            ))
+            FROM mem_links l
+            JOIN mem_records linked ON linked.id = l.to_id
+            WHERE l.from_id = r.id
+        ), '[]'::jsonb),
+        'incoming', COALESCE((
+            SELECT jsonb_agg(jsonb_build_object(
+                'relation', l.relation,
+                'bidirectional', l.bidirectional,
+                'metadata', l.metadata,
+                'record', jsonb_build_object(
+                    'id', linked.id,
+                    'type', linked.type,
+                    'data', linked.data
+                )
+            ))
+            FROM mem_links l
+            JOIN mem_records linked ON linked.id = l.from_id
+            WHERE l.to_id = r.id
+        ), '[]'::jsonb)
+    )
+    FROM mem_records r
+    WHERE r.id = record_id;
+$$;
+
+CREATE OR REPLACE FUNCTION mem_get_linked(
+    record_id UUID,
+    relation_type TEXT DEFAULT NULL,
+    direction TEXT DEFAULT 'outgoing'
+)
+RETURNS TABLE (
+    id UUID,
+    type TEXT,
+    data JSONB,
+    relation TEXT,
+    bidirectional BOOLEAN,
+    link_metadata JSONB
+)
+LANGUAGE sql
+AS $$
+    -- Outgoing links (from this record to others)
+    SELECT
+        r.id,
+        r.type,
+        r.data,
+        l.relation,
+        l.bidirectional,
+        l.metadata
+    FROM mem_links l
+    JOIN mem_records r ON r.id = l.to_id
+    WHERE l.from_id = record_id
+    AND (relation_type IS NULL OR l.relation = relation_type)
+    AND (direction = 'outgoing' OR direction = 'both')
+
+    UNION ALL
+
+    -- Incoming links (from others to this record)
+    -- Only include if bidirectional=true OR direction includes incoming
+    SELECT
+        r.id,
+        r.type,
+        r.data,
+        l.relation,
+        l.bidirectional,
+        l.metadata
+    FROM mem_links l
+    JOIN mem_records r ON r.id = l.from_id
+    WHERE l.to_id = record_id
+    AND (relation_type IS NULL OR l.relation = relation_type)
+    AND (
+        direction = 'incoming'
+        OR direction = 'both'
+        OR l.bidirectional = true
+    );
+$$;
+
+-- =============================================================================
+-- LINK OPERATIONS
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_create_link(
+    from_record_id UUID,
+    to_record_id UUID,
+    relation_type TEXT,
+    is_bidirectional BOOLEAN DEFAULT false,
+    link_metadata JSONB DEFAULT NULL
+)
+RETURNS UUID
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    link_id UUID;
+BEGIN
+    INSERT INTO mem_links (from_id, to_id, relation, bidirectional, metadata)
+    VALUES (from_record_id, to_record_id, relation_type, is_bidirectional, link_metadata)
+    ON CONFLICT (from_id, to_id, relation) DO UPDATE
+    SET bidirectional = is_bidirectional,
+        metadata = COALESCE(link_metadata, mem_links.metadata)
+    RETURNING id INTO link_id;
+    RETURN link_id;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION mem_remove_link(
+    from_record_id UUID,
+    to_record_id UUID,
+    relation_type TEXT
+)
+RETURNS BOOLEAN
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    DELETE FROM mem_links
+    WHERE from_id = from_record_id
+    AND to_id = to_record_id
+    AND relation = relation_type;
+    RETURN FOUND;
+END;
+$$;
+
+-- =============================================================================
+-- TRIGGERS
+-- =============================================================================
+
+CREATE OR REPLACE FUNCTION mem_extract_searchable_text(record_type TEXT, record_data JSONB)
+RETURNS TEXT
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    -- Generic extraction: concatenate all string values
+    RETURN (SELECT string_agg(value::TEXT, ' ')
+            FROM jsonb_each_text(record_data)
+            WHERE value IS NOT NULL AND value != '');
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION mem_records_trigger()
+RETURNS TRIGGER
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    NEW.searchable_text := mem_extract_searchable_text(NEW.type, NEW.data);
+    NEW.updated_at := NOW();
+    RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS mem_records_before_upsert ON mem_records;
+CREATE TRIGGER mem_records_before_upsert
+BEFORE INSERT OR UPDATE ON mem_records
+FOR EACH ROW
+EXECUTE FUNCTION mem_records_trigger();
+`;
+// Full migration SQL (combines schema + vector index + functions)
+export function getMigrationSQL() {
+    return `${SCHEMA_SQL}\n\n${VECTOR_INDEX_SQL}\n\n${FUNCTIONS_SQL}`;
+}
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAEtC,MAAM,CAAC,MAAM,UAAU,GAAG;;;;cAIZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDA6E4B,cAAc;2CAC3B,cAAc;CACxD,CAAC;AAEF,oCAAoC;AACpC,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;CAO/B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsZ5B,CAAC;AAEF,kEAAkE;AAClE,MAAM,UAAU,eAAe;IAC7B,OAAO,GAAG,UAAU,OAAO,gBAAgB,OAAO,aAAa,EAAE,CAAC;AACpE,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Mem Type Definitions
+ */
+export interface MemRecord {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    tags?: string[];
+    embedding?: number[];
+    searchable_text?: string;
+    weight: number;
+    access_count: number;
+    last_accessed_at?: string;
+    status: "active" | "archived";
+    created_at: string;
+    updated_at: string;
+}
+export interface MemLink {
+    id: string;
+    from_id: string;
+    to_id: string;
+    relation: string;
+    bidirectional: boolean;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+}
+export interface MemRecordWithLinks extends MemRecord {
+    outgoing: Array<{
+        relation: string;
+        bidirectional: boolean;
+        metadata?: Record<string, unknown>;
+        record: {
+            id: string;
+            type: string;
+            data: Record<string, unknown>;
+        };
+    }>;
+    incoming: Array<{
+        relation: string;
+        bidirectional: boolean;
+        metadata?: Record<string, unknown>;
+        record: {
+            id: string;
+            type: string;
+            data: Record<string, unknown>;
+        };
+    }>;
+}
+export interface SearchResult {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    tags?: string[];
+    fts_rank: number;
+    semantic_rank: number;
+    combined_score: number;
+}
+export interface ContextResult {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    tags?: string[];
+    weight: number;
+    access_count: number;
+    relevance_score: number;
+}
+export interface AddRecordOptions {
+    tags?: string[];
+    weight?: number;
+    generateEmbedding?: boolean;
+}
+export interface UpdateRecordOptions {
+    tags?: string[];
+    regenerateEmbedding?: boolean;
+}
+export interface SearchOptions {
+    limit?: number;
+    type?: string;
+    ftsWeight?: number;
+    semanticWeight?: number;
+    includeArchived?: boolean;
+    trackAccess?: boolean;
+}
+export interface ContextOptions {
+    limit?: number;
+    types?: string[];
+}
+export interface LinkedOptions {
+    relation?: string;
+    direction?: "outgoing" | "incoming" | "both";
+}
+export interface LinkedRecord {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    relation: string;
+    bidirectional: boolean;
+    link_metadata?: Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Mem Type Definitions
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}