@twelvehart/supermemory-runtime 1.0.0-next.0

package/src/db/postgres.ts

@@ -0,0 +1,72 @@
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { migrate } from 'drizzle-orm/node-postgres/migrator'
+import pkg from 'pg'
+const { Pool } = pkg
+import * as schema from './schema/index.js'
+
+let db: ReturnType<typeof drizzle<typeof schema>> | null = null
+let pool: pkg.Pool | null = null
+
+function parsePoolNumberEnv(name: string, fallback: number): number {
+  const rawValue = process.env[name]
+  if (!rawValue) return fallback
+
+  const parsed = Number.parseInt(rawValue, 10)
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+export function getPostgresPoolConfig(): Pick<
+  pkg.PoolConfig,
+  'min' | 'max' | 'idleTimeoutMillis' | 'connectionTimeoutMillis'
+> {
+  return {
+    min: parsePoolNumberEnv('SUPERMEMORY_PG_POOL_MIN', 10),
+    max: parsePoolNumberEnv('SUPERMEMORY_PG_POOL_MAX', 100),
+    idleTimeoutMillis: parsePoolNumberEnv('SUPERMEMORY_PG_POOL_IDLE_TIMEOUT_MS', 30000),
+    connectionTimeoutMillis: parsePoolNumberEnv('SUPERMEMORY_PG_POOL_CONNECTION_TIMEOUT_MS', 2000),
+  }
+}
+
+export function createPostgresDatabase(connectionString: string) {
+  // Create connection pool
+  pool = new Pool({
+    connectionString,
+    ...getPostgresPoolConfig(),
+  })
+
+  // Enable pgvector extension on connection
+  pool.on('connect', async (client) => {
+    try {
+      await client.query('CREATE EXTENSION IF NOT EXISTS vector')
+    } catch (error) {
+      console.error('Error enabling pgvector extension:', error)
+    }
+  })
+
+  return drizzle(pool, { schema })
+}
+
+export function getPostgresDatabase(connectionString: string) {
+  if (!db) {
+    db = createPostgresDatabase(connectionString)
+  }
+  return db
+}
+
+export async function runPostgresMigrations(connectionString: string) {
+  const database = getPostgresDatabase(connectionString)
+  await migrate(database, { migrationsFolder: './drizzle' })
+  console.log('PostgreSQL migrations completed successfully')
+}
+
+export async function closePostgresDatabase() {
+  if (pool) {
+    await pool.end()
+    pool = null
+    db = null
+  }
+}
+
+export type PostgresDatabaseInstance = ReturnType<typeof createPostgresDatabase>
+
+export { schema }

package/src/db/schema/chunks.schema.ts

@@ -0,0 +1,31 @@
+import { pgTable, uuid, text, integer, jsonb, timestamp, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+import { memories } from './memories.schema.js'
+
+export const chunks = pgTable(
+  'chunks',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    memoryId: uuid('memory_id')
+      .notNull()
+      .references(() => memories.id, { onDelete: 'cascade' }),
+    content: text('content').notNull(),
+    chunkIndex: integer('chunk_index').notNull(),
+    startOffset: integer('start_offset'),
+    endOffset: integer('end_offset'),
+    tokenCount: integer('token_count'),
+    metadata: jsonb('metadata').default(sql`'{}'::jsonb`),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    index('idx_chunks_memory_id').on(table.memoryId),
+    index('idx_chunks_chunk_index').on(table.memoryId, table.chunkIndex),
+    index('idx_chunks_token_count').on(table.tokenCount),
+    index('idx_chunks_metadata').using('gin', sql`${table.metadata} jsonb_path_ops`),
+  ]
+)
+
+export type Chunk = typeof chunks.$inferSelect
+export type NewChunk = typeof chunks.$inferInsert

package/src/db/schema/containers.schema.ts

@@ -0,0 +1,46 @@
+import {
+  pgTable,
+  uuid,
+  varchar,
+  text,
+  jsonb,
+  boolean,
+  timestamp,
+  index,
+  check,
+  type AnyPgColumn,
+} from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+export const containerTags = pgTable(
+  'container_tags',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    tag: varchar('tag', { length: 255 }).notNull().unique(),
+    parentTag: varchar('parent_tag', { length: 255 }).references((): AnyPgColumn => containerTags.tag, {
+      onDelete: 'set null',
+    }),
+    displayName: varchar('display_name', { length: 255 }),
+    description: text('description'),
+    metadata: jsonb('metadata').default(sql`'{}'::jsonb`),
+    settings: jsonb('settings').default(sql`'{}'::jsonb`),
+    isActive: boolean('is_active').notNull().default(true),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    index('idx_container_tags_parent').on(table.parentTag),
+    index('idx_container_tags_active')
+      .on(table.isActive)
+      .where(sql`${table.isActive} = TRUE`),
+    index('idx_container_tags_metadata').using('gin', table.metadata),
+    index('idx_container_tags_hierarchy').on(table.tag, table.parentTag),
+    check('container_tags_no_self_parent', sql`${table.tag} != ${table.parentTag}`),
+    check('container_tags_tag_format', sql`${table.tag} ~ '^[a-zA-Z0-9_-]+$'`),
+  ]
+)
+
+export type ContainerTag = typeof containerTags.$inferSelect
+export type NewContainerTag = typeof containerTags.$inferInsert

package/src/db/schema/documents.schema.ts

@@ -0,0 +1,49 @@
+import { pgTable, uuid, varchar, text, jsonb, timestamp, index, check, integer } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+
+export const documents = pgTable(
+  'documents',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    customId: varchar('custom_id', { length: 255 }),
+    content: text('content').notNull(),
+    contentType: varchar('content_type', { length: 50 }).notNull().default('text/plain'),
+    status: varchar('status', { length: 20 }).notNull().default('pending'),
+    containerTag: varchar('container_tag', { length: 255 }).notNull(),
+    metadata: jsonb('metadata').default(sql`'{}'::jsonb`),
+    contentHash: varchar('content_hash', { length: 64 })
+      .generatedAlwaysAs(sql`encode(sha256(content::bytea), 'hex')`)
+      .notNull(),
+    wordCount: integer('word_count')
+      .generatedAlwaysAs(sql`array_length(regexp_split_to_array(content, '\\s+'), 1)`)
+      .notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    index('idx_documents_container_tag').on(table.containerTag),
+    index('idx_documents_status')
+      .on(table.status)
+      .where(sql`${table.status} != 'processed'`),
+    index('idx_documents_custom_id')
+      .on(table.customId)
+      .where(sql`${table.customId} IS NOT NULL`),
+    index('idx_documents_content_hash').on(table.contentHash),
+    index('idx_documents_created_at').on(table.createdAt.desc()),
+    index('idx_documents_metadata').using('gin', sql`${table.metadata} jsonb_path_ops`),
+    index('idx_documents_container_status').on(table.containerTag, table.status, table.createdAt),
+    check(
+      'documents_status_check',
+      sql`${table.status} IN ('pending', 'processing', 'processed', 'failed', 'archived')`
+    ),
+    check(
+      'documents_content_type_check',
+      sql`${table.contentType} IN ('text/plain', 'text/markdown', 'text/html', 'application/pdf', 'application/json', 'image/png', 'image/jpeg', 'audio/mp3', 'video/mp4')`
+    ),
+  ]
+)
+
+export type Document = typeof documents.$inferSelect
+export type NewDocument = typeof documents.$inferInsert

package/src/db/schema/embeddings.schema.ts

@@ -0,0 +1,32 @@
+import { pgTable, uuid, varchar, boolean, timestamp, index, check } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+import { vector } from 'drizzle-orm/pg-core'
+import { memories } from './memories.schema.js'
+
+export const memoryEmbeddings = pgTable(
+  'memory_embeddings',
+  {
+    memoryId: uuid('memory_id')
+      .primaryKey()
+      .references(() => memories.id, { onDelete: 'cascade' }),
+    embedding: vector('embedding', { dimensions: 1536 }).notNull(),
+    model: varchar('model', { length: 100 }).notNull().default('text-embedding-3-small'),
+    modelVersion: varchar('model_version', { length: 50 }),
+    normalized: boolean('normalized').default(true),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    // HNSW index for approximate nearest neighbor search with cosine similarity
+    index('idx_memory_embeddings_hnsw')
+      .using('hnsw', table.embedding.op('vector_cosine_ops'))
+      .with({ m: 16, ef_construction: 64 }),
+    index('idx_memory_embeddings_model').on(table.model),
+    check(
+      'memory_embeddings_model_check',
+      sql`${table.model} IN ('text-embedding-3-small', 'text-embedding-3-large', 'text-embedding-ada-002', 'voyage-large-2', 'voyage-code-2', 'cohere-embed-v3', 'bge-large-en-v1.5', 'custom')`
+    ),
+  ]
+)
+
+export type MemoryEmbedding = typeof memoryEmbeddings.$inferSelect
+export type NewMemoryEmbedding = typeof memoryEmbeddings.$inferInsert

package/src/db/schema/index.ts

@@ -0,0 +1,11 @@
+// PostgreSQL Schema Exports
+// This file aggregates all schema definitions for the supermemory PostgreSQL database
+
+export * from './containers.schema.js'
+export * from './documents.schema.js'
+export * from './memories.schema.js'
+export * from './chunks.schema.js'
+export * from './embeddings.schema.js'
+export * from './relationships.schema.js'
+export * from './profiles.schema.js'
+export * from './queue.schema.js'

package/src/db/schema/memories.schema.ts

@@ -0,0 +1,72 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  varchar,
+  boolean,
+  integer,
+  decimal,
+  jsonb,
+  timestamp,
+  index,
+  check,
+  type AnyPgColumn,
+} from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+import { documents } from './documents.schema.js'
+
+export const memories = pgTable(
+  'memories',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    documentId: uuid('document_id').references(() => documents.id, { onDelete: 'set null' }),
+    content: text('content').notNull(),
+    memoryType: varchar('memory_type', { length: 20 }).notNull().default('fact'),
+    isLatest: boolean('is_latest').notNull().default(true),
+    similarityHash: varchar('similarity_hash', { length: 64 }).notNull(),
+    version: integer('version').notNull().default(1),
+    supersedesId: uuid('supersedes_id').references((): AnyPgColumn => memories.id, {
+      onDelete: 'set null',
+    }),
+    containerTag: varchar('container_tag', { length: 255 }).notNull(),
+    confidenceScore: decimal('confidence_score', { precision: 4, scale: 3 }).default('1.000'),
+    metadata: jsonb('metadata').default(sql`'{}'::jsonb`),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    index('idx_memories_document_id')
+      .on(table.documentId)
+      .where(sql`${table.documentId} IS NOT NULL`),
+    index('idx_memories_container_tag').on(table.containerTag),
+    index('idx_memories_type').on(table.memoryType),
+    index('idx_memories_is_latest')
+      .on(table.isLatest)
+      .where(sql`${table.isLatest} = TRUE`),
+    index('idx_memories_similarity_hash').on(table.similarityHash),
+    index('idx_memories_supersedes')
+      .on(table.supersedesId)
+      .where(sql`${table.supersedesId} IS NOT NULL`),
+    index('idx_memories_metadata').using('gin', sql`${table.metadata} jsonb_path_ops`),
+    index('idx_memories_created_at').on(table.createdAt.desc()),
+    index('idx_memories_container_latest')
+      .on(table.containerTag, table.isLatest, table.createdAt)
+      .where(sql`${table.isLatest} = TRUE`),
+    index('idx_memories_container_type_latest')
+      .on(table.containerTag, table.memoryType, table.isLatest)
+      .where(sql`${table.isLatest} = TRUE`),
+    index('idx_memories_version_chain')
+      .on(table.supersedesId, table.version)
+      .where(sql`${table.supersedesId} IS NOT NULL`),
+    check(
+      'memories_type_check',
+      sql`${table.memoryType} IN ('fact', 'preference', 'episode', 'belief', 'skill', 'context')`
+    ),
+    check('memories_confidence_check', sql`${table.confidenceScore} >= 0 AND ${table.confidenceScore} <= 1`),
+  ]
+)
+
+export type Memory = typeof memories.$inferSelect
+export type NewMemory = typeof memories.$inferInsert

package/src/db/schema/profiles.schema.ts

@@ -0,0 +1,34 @@
+import { pgTable, uuid, varchar, jsonb, timestamp, integer, index } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+import { containerTags } from './containers.schema.js'
+
+export const userProfiles = pgTable(
+  'user_profiles',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    containerTag: varchar('container_tag', { length: 255 })
+      .notNull()
+      .unique()
+      .references(() => containerTags.tag, { onDelete: 'cascade' }),
+    staticFacts: jsonb('static_facts').default(sql`'[]'::jsonb`),
+    dynamicFacts: jsonb('dynamic_facts').default(sql`'[]'::jsonb`),
+    preferences: jsonb('preferences').default(sql`'{}'::jsonb`),
+    computedTraits: jsonb('computed_traits').default(sql`'{}'::jsonb`),
+    lastInteractionAt: timestamp('last_interaction_at', { withTimezone: true }),
+    memoryCount: integer('memory_count').default(0),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    index('idx_user_profiles_container').on(table.containerTag),
+    index('idx_user_profiles_static_facts').using('gin', table.staticFacts),
+    index('idx_user_profiles_dynamic_facts').using('gin', table.dynamicFacts),
+    index('idx_user_profiles_preferences').using('gin', table.preferences),
+    index('idx_user_profiles_updated').on(table.updatedAt.desc()),
+  ]
+)
+
+export type UserProfile = typeof userProfiles.$inferSelect
+export type NewUserProfile = typeof userProfiles.$inferInsert

package/src/db/schema/queue.schema.ts

@@ -0,0 +1,59 @@
+import { pgTable, uuid, varchar, text, integer, jsonb, timestamp, index, check } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+import { documents } from './documents.schema.js'
+
+export const processingQueue = pgTable(
+  'processing_queue',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    documentId: uuid('document_id')
+      .notNull()
+      .references(() => documents.id, { onDelete: 'cascade' }),
+    stage: varchar('stage', { length: 30 }).notNull().default('extraction'),
+    status: varchar('status', { length: 20 }).notNull().default('pending'),
+    priority: integer('priority').default(0),
+    error: text('error'),
+    errorCode: varchar('error_code', { length: 50 }),
+    attempts: integer('attempts').default(0),
+    maxAttempts: integer('max_attempts').default(3),
+    workerId: varchar('worker_id', { length: 100 }),
+    metadata: jsonb('metadata').default(sql`'{}'::jsonb`),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    startedAt: timestamp('started_at', { withTimezone: true }),
+    completedAt: timestamp('completed_at', { withTimezone: true }),
+    scheduledAt: timestamp('scheduled_at', { withTimezone: true }).defaultNow(),
+  },
+  (table) => [
+    index('idx_processing_queue_document').on(table.documentId),
+    index('idx_processing_queue_status')
+      .on(table.status)
+      .where(sql`${table.status} IN ('pending', 'retry')`),
+    index('idx_processing_queue_stage').on(table.stage),
+    index('idx_processing_queue_worker')
+      .on(table.workerId)
+      .where(sql`${table.workerId} IS NOT NULL`),
+    index('idx_processing_queue_priority')
+      .on(table.priority.desc(), table.scheduledAt.asc())
+      .where(sql`${table.status} IN ('pending', 'retry')`),
+    index('idx_processing_queue_stale')
+      .on(table.startedAt)
+      .where(sql`${table.status} = 'processing'`),
+    index('idx_processing_queue_worker_select')
+      .on(table.status, table.stage, table.priority, table.scheduledAt)
+      .where(sql`${table.status} IN ('pending', 'retry')`),
+    check(
+      'processing_queue_stage_check',
+      sql`${table.stage} IN ('extraction', 'embedding', 'deduplication', 'relationship', 'profile_update', 'cleanup')`
+    ),
+    check(
+      'processing_queue_status_check',
+      sql`${table.status} IN ('pending', 'processing', 'completed', 'failed', 'cancelled', 'retry')`
+    ),
+    check('processing_queue_attempts_check', sql`${table.attempts} <= ${table.maxAttempts}`),
+  ]
+)
+
+export type ProcessingQueue = typeof processingQueue.$inferSelect
+export type NewProcessingQueue = typeof processingQueue.$inferInsert

package/src/db/schema/relationships.schema.ts

@@ -0,0 +1,42 @@
+import { pgTable, uuid, varchar, decimal, boolean, jsonb, timestamp, index, check, unique } from 'drizzle-orm/pg-core'
+import { sql } from 'drizzle-orm'
+import { memories } from './memories.schema.js'
+
+export const memoryRelationships = pgTable(
+  'memory_relationships',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    sourceMemoryId: uuid('source_memory_id')
+      .notNull()
+      .references(() => memories.id, { onDelete: 'cascade' }),
+    targetMemoryId: uuid('target_memory_id')
+      .notNull()
+      .references(() => memories.id, { onDelete: 'cascade' }),
+    relationshipType: varchar('relationship_type', { length: 30 }).notNull(),
+    weight: decimal('weight', { precision: 4, scale: 3 }).default('1.000'),
+    bidirectional: boolean('bidirectional').default(false),
+    metadata: jsonb('metadata').default(sql`'{}'::jsonb`),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    index('idx_memory_rel_source').on(table.sourceMemoryId),
+    index('idx_memory_rel_target').on(table.targetMemoryId),
+    index('idx_memory_rel_type').on(table.relationshipType),
+    index('idx_memory_rel_bidirectional')
+      .on(table.sourceMemoryId, table.targetMemoryId)
+      .where(sql`${table.bidirectional} = TRUE`),
+    index('idx_memory_rel_graph').on(table.sourceMemoryId, table.targetMemoryId, table.relationshipType, table.weight),
+    check(
+      'memory_relationships_type_check',
+      sql`${table.relationshipType} IN ('updates', 'extends', 'derives', 'contradicts', 'supports', 'relates', 'temporal', 'causal', 'part_of', 'similar')`
+    ),
+    check('memory_relationships_weight_check', sql`${table.weight} >= 0 AND ${table.weight} <= 1`),
+    check('memory_relationships_no_self_loop', sql`${table.sourceMemoryId} != ${table.targetMemoryId}`),
+    unique('memory_relationships_unique_edge').on(table.sourceMemoryId, table.targetMemoryId, table.relationshipType),
+  ]
+)
+
+export type MemoryRelationship = typeof memoryRelationships.$inferSelect
+export type NewMemoryRelationship = typeof memoryRelationships.$inferInsert

package/src/db/schema.ts

@@ -0,0 +1,223 @@
+import { sqliteTable, text, integer, blob, index, uniqueIndex } from 'drizzle-orm/sqlite-core'
+import { sql } from 'drizzle-orm'
+
+// Users table
+export const users = sqliteTable(
+  'users',
+  {
+    id: text('id').primaryKey(),
+    email: text('email').notNull().unique(),
+    name: text('name'),
+    apiKey: text('api_key').notNull().unique(),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer('updated_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [uniqueIndex('users_email_idx').on(table.email), uniqueIndex('users_api_key_idx').on(table.apiKey)]
+)
+
+// Spaces (collections/folders for organizing memories)
+export const spaces = sqliteTable(
+  'spaces',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    name: text('name').notNull(),
+    description: text('description'),
+    isDefault: integer('is_default', { mode: 'boolean' }).notNull().default(false),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer('updated_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [index('spaces_user_id_idx').on(table.userId)]
+)
+
+// Content types enum values
+export const contentTypes = ['note', 'url', 'pdf', 'image', 'tweet', 'document'] as const
+export type ContentType = (typeof contentTypes)[number]
+
+// Memories table (main content storage)
+export const memories = sqliteTable(
+  'memories',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    spaceId: text('space_id').references(() => spaces.id, { onDelete: 'set null' }),
+    contentType: text('content_type', { enum: contentTypes }).notNull(),
+    title: text('title'),
+    content: text('content').notNull(),
+    rawContent: text('raw_content'), // Original content before processing
+    sourceUrl: text('source_url'),
+    metadata: text('metadata', { mode: 'json' }).$type<Record<string, unknown>>(),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer('updated_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [
+    index('memories_user_id_idx').on(table.userId),
+    index('memories_space_id_idx').on(table.spaceId),
+    index('memories_content_type_idx').on(table.contentType),
+    index('memories_created_at_idx').on(table.createdAt),
+  ]
+)
+
+// Chunks table (for RAG - split content into searchable chunks)
+export const chunks = sqliteTable(
+  'chunks',
+  {
+    id: text('id').primaryKey(),
+    memoryId: text('memory_id')
+      .notNull()
+      .references(() => memories.id, { onDelete: 'cascade' }),
+    content: text('content').notNull(),
+    chunkIndex: integer('chunk_index').notNull(),
+    startOffset: integer('start_offset'),
+    endOffset: integer('end_offset'),
+    tokenCount: integer('token_count'),
+    metadata: text('metadata', { mode: 'json' }).$type<Record<string, unknown>>(),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [index('chunks_memory_id_idx').on(table.memoryId), index('chunks_chunk_index_idx').on(table.chunkIndex)]
+)
+
+// Embeddings table (vector storage for semantic search)
+export const embeddings = sqliteTable(
+  'embeddings',
+  {
+    id: text('id').primaryKey(),
+    chunkId: text('chunk_id')
+      .notNull()
+      .references(() => chunks.id, { onDelete: 'cascade' }),
+    embedding: blob('embedding', { mode: 'buffer' }).notNull(), // Stored as binary for efficiency
+    model: text('model').notNull(),
+    dimensions: integer('dimensions').notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [uniqueIndex('embeddings_chunk_id_idx').on(table.chunkId)]
+)
+
+// Tags table
+export const tags = sqliteTable(
+  'tags',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    name: text('name').notNull(),
+    color: text('color'),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [
+    index('tags_user_id_idx').on(table.userId),
+    uniqueIndex('tags_user_name_idx').on(table.userId, table.name),
+  ]
+)
+
+// Memory-Tags junction table
+export const memoryTags = sqliteTable(
+  'memory_tags',
+  {
+    memoryId: text('memory_id')
+      .notNull()
+      .references(() => memories.id, { onDelete: 'cascade' }),
+    tagId: text('tag_id')
+      .notNull()
+      .references(() => tags.id, { onDelete: 'cascade' }),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [index('memory_tags_memory_id_idx').on(table.memoryId), index('memory_tags_tag_id_idx').on(table.tagId)]
+)
+
+// Search history for analytics and suggestions
+export const searchHistory = sqliteTable(
+  'search_history',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    query: text('query').notNull(),
+    resultCount: integer('result_count').notNull().default(0),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [
+    index('search_history_user_id_idx').on(table.userId),
+    index('search_history_created_at_idx').on(table.createdAt),
+  ]
+)
+
+// API usage tracking
+export const apiUsage = sqliteTable(
+  'api_usage',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    endpoint: text('endpoint').notNull(),
+    method: text('method').notNull(),
+    statusCode: integer('status_code').notNull(),
+    responseTimeMs: integer('response_time_ms'),
+    tokensUsed: integer('tokens_used'),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [
+    index('api_usage_user_id_idx').on(table.userId),
+    index('api_usage_endpoint_idx').on(table.endpoint),
+    index('api_usage_created_at_idx').on(table.createdAt),
+  ]
+)
+
+// Type exports for use in application
+export type User = typeof users.$inferSelect
+export type NewUser = typeof users.$inferInsert
+
+export type Space = typeof spaces.$inferSelect
+export type NewSpace = typeof spaces.$inferInsert
+
+export type Memory = typeof memories.$inferSelect
+export type NewMemory = typeof memories.$inferInsert
+
+export type Chunk = typeof chunks.$inferSelect
+export type NewChunk = typeof chunks.$inferInsert
+
+export type Embedding = typeof embeddings.$inferSelect
+export type NewEmbedding = typeof embeddings.$inferInsert
+
+export type Tag = typeof tags.$inferSelect
+export type NewTag = typeof tags.$inferInsert
+
+export type MemoryTag = typeof memoryTags.$inferSelect
+export type NewMemoryTag = typeof memoryTags.$inferInsert
+
+export type SearchHistory = typeof searchHistory.$inferSelect
+export type NewSearchHistory = typeof searchHistory.$inferInsert
+
+export type ApiUsage = typeof apiUsage.$inferSelect
+export type NewApiUsage = typeof apiUsage.$inferInsert