llmemory 0.2.0 → 0.2.1

data/lib/llmemory/long_term/episodic/storages/database_storage.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "time"
+require_relative "base"
+
+module Llmemory
+  module LongTerm
+    module Episodic
+      module Storages
+        # PostgreSQL backend. Each episode is stored as a JSONB `data` document
+        # (plus id/user_id/created_at and a denormalized search_text for keyword
+        # search), mirroring the file-based DatabaseStorage pattern.
+        class DatabaseStorage < Base
+          def initialize(database_url: nil)
+            @database_url = database_url || Llmemory.configuration.database_url
+            @connection = nil
+          end
+
+          def save_episode(user_id, episode)
+            ensure_tables!
+            id = episode[:id] || episode["id"] || "ep_#{SecureRandom.hex(8)}"
+            data = symbolize(episode).merge(id: id, user_id: user_id)
+            data[:created_at] ||= Time.now.utc.iso8601
+            conn.exec_params(
+              "INSERT INTO llmemory_episodes (id, user_id, data, search_text, created_at) " \
+              "VALUES ($1, $2, $3::jsonb, $4, $5) " \
+              "ON CONFLICT (id) DO UPDATE SET data = $3::jsonb, search_text = $4",
+              [id, user_id, JSON.generate(data), searchable_text(data), created_at_value(data)]
+            )
+            id
+          end
+
+          def get_episode(user_id, id)
+            ensure_tables!
+            rows = conn.exec_params("SELECT data FROM llmemory_episodes WHERE user_id = $1 AND id = $2", [user_id, id])
+            rows.any? ? parse_data(rows.first["data"]) : nil
+          end
+
+          def list_episodes(user_id, limit: nil)
+            ensure_tables!
+            sql = "SELECT data FROM llmemory_episodes WHERE user_id = $1 ORDER BY created_at DESC"
+            sql += " LIMIT #{limit.to_i}" if limit && limit.to_i.positive?
+            conn.exec_params(sql, [user_id]).map { |r| parse_data(r["data"]) }
+          end
+
+          def search_episodes(user_id, query)
+            ensure_tables!
+            suffix, params = token_filter("search_text", query, 2)
+            conn.exec_params(
+              "SELECT data FROM llmemory_episodes WHERE user_id = $1#{suffix} ORDER BY created_at DESC",
+              [user_id, *params]
+            ).map { |r| parse_data(r["data"]) }
+          end
+
+          def count_episodes(user_id)
+            ensure_tables!
+            conn.exec_params("SELECT COUNT(*) AS c FROM llmemory_episodes WHERE user_id = $1", [user_id]).first["c"].to_i
+          end
+
+          def delete_episodes(user_id, ids)
+            ensure_tables!
+            Array(ids).sum do |id|
+              conn.exec_params("DELETE FROM llmemory_episodes WHERE user_id = $1 AND id = $2", [user_id, id]).cmd_tuples
+            end
+          end
+
+          def list_users
+            ensure_tables!
+            conn.exec("SELECT DISTINCT user_id FROM llmemory_episodes").map { |r| r["user_id"] }
+          end
+
+          private
+
+          def conn
+            @connection ||= begin
+              require "pg"
+              PG.connect(@database_url)
+            end
+          end
+
+          def ensure_tables!
+            conn.exec(<<~SQL)
+              CREATE TABLE IF NOT EXISTS llmemory_episodes (
+                id TEXT NOT NULL PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                data JSONB NOT NULL DEFAULT '{}'::jsonb,
+                search_text TEXT,
+                created_at TIMESTAMPTZ NOT NULL
+              );
+              CREATE INDEX IF NOT EXISTS idx_llmemory_episodes_user_id ON llmemory_episodes(user_id);
+            SQL
+          end
+
+          # OR-of-token LIKE filter (see file-based DatabaseStorage). [""] for an
+          # empty query => match all.
+          def token_filter(column, query, start_index)
+            tokens = Llmemory::Tokenizer.tokenize(query)
+            return ["", []] if tokens.empty?
+            likes = tokens.each_index.map { |i| "LOWER(#{column}) LIKE $#{start_index + i}" }
+            [" AND (#{likes.join(' OR ')})", tokens.map { |t| "%#{t}%" }]
+          end
+
+          def parse_data(value)
+            JSON.parse(value.to_s, symbolize_names: true)
+          rescue JSON::ParserError
+            {}
+          end
+
+          def symbolize(hash)
+            hash.each_with_object({}) { |(k, v), acc| acc[k.to_sym] = v }
+          end
+
+          def searchable_text(data)
+            parts = [data[:summary], data[:outcome]]
+            Array(data[:steps]).each do |s|
+              next unless s.is_a?(Hash)
+              parts << (s[:observation] || s["observation"])
+              parts << (s[:action] || s["action"])
+              parts << (s[:result] || s["result"])
+            end
+            parts.compact.join("\n")
+          end
+
+          def created_at_value(data)
+            ca = data[:created_at]
+            return Time.now.utc.iso8601 if ca.nil?
+            ca.respond_to?(:iso8601) ? ca.iso8601 : ca.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/episodic/storages/file_storage.rb

@@ -35,9 +35,8 @@ module Llmemory
           end
 
           def search_episodes(user_id, query)
-            q = query.to_s.downcase
-            return list_episodes(user_id) if q.strip.empty?
-            all_episodes(user_id).select { |e| episode_text(e).downcase.include?(q) }
+            return list_episodes(user_id) if query.to_s.strip.empty?
+            all_episodes(user_id).select { |e| Llmemory::Tokenizer.matches?(episode_text(e), query) }
           end
 
           def count_episodes(user_id)

data/lib/llmemory/long_term/episodic/storages/memory_storage.rb

@@ -31,9 +31,8 @@ module Llmemory
           end
 
           def search_episodes(user_id, query)
-            q = query.to_s.downcase
-            return list_episodes(user_id) if q.strip.empty?
-            @episodes[user_id].select { |e| episode_text(e).downcase.include?(q) }
+            return list_episodes(user_id) if query.to_s.strip.empty?
+            @episodes[user_id].select { |e| Llmemory::Tokenizer.matches?(episode_text(e), query) }
           end
 
           def count_episodes(user_id)

data/lib/llmemory/long_term/file_based/storages/active_record_storage.rb

@@ -64,13 +64,11 @@ module Llmemory
           end
 
           def search_items(user_id, query)
-            q = "%#{sanitize_like(query)}%"
-            LlmemoryItem.where(user_id: user_id).where("LOWER(content) LIKE LOWER(?)", q).map { |r| row_to_item(r) }
+            token_scope(LlmemoryItem.where(user_id: user_id), "content", query).map { |r| row_to_item(r) }
           end
 
           def search_resources(user_id, query)
-            q = "%#{sanitize_like(query)}%"
-            LlmemoryResource.where(user_id: user_id).where("LOWER(text) LIKE LOWER(?)", q).map { |r| row_to_resource(r) }
+            token_scope(LlmemoryResource.where(user_id: user_id), "text", query).map { |r| row_to_resource(r) }
           end
 
           def get_resources_since(user_id, hours:)
@@ -181,6 +179,15 @@ module Llmemory
             (str || "").to_s.gsub(/[%_\\]/) { |c| "\\#{c}" }
           end
 
+          # OR-of-token LIKE scope for keyword search; unchanged scope (match all)
+          # when the query has no tokens.
+          def token_scope(scope, column, query)
+            tokens = Llmemory::Tokenizer.tokenize(query)
+            return scope if tokens.empty?
+            clause = tokens.map { "LOWER(#{column}) LIKE LOWER(?)" }.join(" OR ")
+            scope.where(clause, *tokens.map { |t| "%#{sanitize_like(t)}%" })
+          end
+
           def row_to_item(r)
             h = {
               id: r.id,

data/lib/llmemory/long_term/file_based/storages/database_storage.rb

@@ -65,20 +65,20 @@ module Llmemory
 
           def search_items(user_id, query)
             ensure_tables!
-            pattern = "%#{conn.escape_string(query.to_s.downcase)}%"
+            suffix, params = token_filter("content", query, 2)
             rows = conn.exec_params(
-              "SELECT id, category, content, source_resource_id, importance, provenance, created_at FROM llmemory_items WHERE user_id = $1 AND LOWER(content) LIKE $2",
-              [user_id, pattern]
+              "SELECT id, category, content, source_resource_id, importance, provenance, created_at FROM llmemory_items WHERE user_id = $1#{suffix}",
+              [user_id, *params]
             )
             rows_to_items(rows)
           end
 
           def search_resources(user_id, query)
             ensure_tables!
-            pattern = "%#{conn.escape_string(query.to_s.downcase)}%"
+            suffix, params = token_filter("text", query, 2)
             rows = conn.exec_params(
-              "SELECT id, text, created_at FROM llmemory_resources WHERE user_id = $1 AND LOWER(text) LIKE $2",
-              [user_id, pattern]
+              "SELECT id, text, created_at FROM llmemory_resources WHERE user_id = $1#{suffix}",
+              [user_id, *params]
             )
             rows_to_resources(rows)
           end
@@ -290,6 +290,16 @@ module Llmemory
             end
           end
 
+          # Builds an OR-of-token LIKE filter for keyword search. Returns
+          # ["" , []] for an empty query (match all). Tokens are [a-z0-9]{2,} so
+          # they carry no LIKE wildcards.
+          def token_filter(column, query, start_index)
+            tokens = Llmemory::Tokenizer.tokenize(query)
+            return ["", []] if tokens.empty?
+            likes = tokens.each_index.map { |i| "LOWER(#{column}) LIKE $#{start_index + i}" }
+            [" AND (#{likes.join(' OR ')})", tokens.map { |t| "%#{t}%" }]
+          end
+
           def parse_provenance(value)
             return nil if value.nil? || value.to_s.strip.empty?
             JSON.parse(value, symbolize_names: true)

data/lib/llmemory/long_term/file_based/storages/file_storage.rb

@@ -62,13 +62,11 @@ module Llmemory
           end
 
           def search_items(user_id, query)
-            query_lower = query.downcase
-            get_all_items(user_id).select { |i| (i[:content] || i["content"]).to_s.downcase.include?(query_lower) }
+            get_all_items(user_id).select { |i| Llmemory::Tokenizer.matches?(i[:content] || i["content"], query) }
           end
 
           def search_resources(user_id, query)
-            query_lower = query.downcase
-            get_all_resources(user_id).select { |r| (r[:text] || r["text"]).to_s.downcase.include?(query_lower) }
+            get_all_resources(user_id).select { |r| Llmemory::Tokenizer.matches?(r[:text] || r["text"], query) }
           end
 
           def get_resources_since(user_id, hours:)

data/lib/llmemory/long_term/file_based/storages/memory_storage.rb

@@ -51,13 +51,11 @@ module Llmemory
           end
 
           def search_items(user_id, query)
-            query_lower = query.downcase
-            @items[user_id].select { |i| i[:content].to_s.downcase.include?(query_lower) }
+            @items[user_id].select { |i| Llmemory::Tokenizer.matches?(i[:content], query) }
           end
 
           def search_resources(user_id, query)
-            query_lower = query.downcase
-            @resources[user_id].select { |r| r[:text].to_s.downcase.include?(query_lower) }
+            @resources[user_id].select { |r| Llmemory::Tokenizer.matches?(r[:text], query) }
           end
 
           def get_resources_since(user_id, hours:)

data/lib/llmemory/long_term/graph_based/memory.rb

@@ -28,55 +28,11 @@ module Llmemory
           text = Llmemory.configuration.noise_filter_enabled ? NoiseFilter.filter?(conversation_text) : conversation_text.to_s
           return true if text.strip.empty?
 
-          data = @extractor.extract(text) rescue { entities: [], relations: [] }
-          data = { entities: [], relations: [] } unless data.is_a?(Hash)
-          entities = Array(data[:entities] || data["entities"])
-          relations = Array(data[:relations] || data["relations"])
-
+          entities, relations = extract_graph(text)
           return true if entities.empty? && relations.empty?
 
           provenance = Llmemory::Provenance.from_text_fingerprint(text, method: "entity_relation_extraction")
-          name_to_id = {}
-
-          entities.each do |e|
-            next unless e.is_a?(Hash)
-            entity_type = e[:type] || e["type"] || "concept"
-            name = e[:name] || e["name"]
-            next if name.nil? || name.to_s.strip.empty?
-            id = @kg.add_node(entity_type: entity_type, name: name.to_s.strip, properties: { "provenance" => provenance })
-            name_to_id[name.to_s.strip] ||= id
-          end
-
-          relations.each do |r|
-            next unless r.is_a?(Hash)
-            subject = (r[:subject] || r["subject"]).to_s.strip
-            predicate = (r[:predicate] || r["predicate"]).to_s.strip
-            object = (r[:object] || r["object"]).to_s.strip
-            next if subject.empty? || predicate.empty? || object.empty?
-
-            subject_id = name_to_id[subject] || @kg.add_node(entity_type: "concept", name: subject, properties: { "provenance" => provenance })
-            object_id = name_to_id[object] || @kg.add_node(entity_type: "concept", name: object, properties: { "provenance" => provenance })
-
-            edge = Edge.new(
-              id: nil,
-              user_id: @user_id,
-              subject_id: subject_id,
-              predicate: predicate,
-              target_id: object_id,
-              properties: { "provenance" => provenance },
-              created_at: Time.now,
-              archived_at: nil
-            )
-            @conflict_resolver.resolve(edge)
-            edge_id = @kg.add_edge(subject: subject_id, predicate: predicate, object: object_id, properties: { "provenance" => provenance })
-
-            text = "#{subject} #{predicate} #{object}"
-            embedding = @vector_store.respond_to?(:embed) ? @vector_store.embed(text) : nil
-            if embedding && @vector_store.respond_to?(:store)
-              @vector_store.store(id: "edge_#{edge_id}", embedding: embedding, metadata: { text: text, created_at: Time.now }, user_id: @user_id)
-            end
-          end
-
+          ingest(entities, relations, provenance)
           true
         end
 
@@ -106,6 +62,19 @@ module Llmemory
           @graph_storage
         end
 
+        # Stores a fact produced outside the conversational flow (e.g. a
+        # reflection insight) by extracting entities/relations from `content` and
+        # adding them to the graph, preserving caller-supplied provenance. Lets
+        # the Reflector target graph-based semantic memory.
+        def remember_fact(content:, category: nil, importance: nil, provenance: nil)
+          return nil if content.to_s.strip.empty?
+          entities, relations = extract_graph(content)
+          return nil if entities.empty? && relations.empty?
+          prov = provenance || Llmemory::Provenance.from_text_fingerprint(content, method: "reflection")
+          ingest(entities, relations, prov)
+          true
+        end
+
         # --- MemoryModule uniform interface ---
 
         def write(payload, **_meta)
@@ -121,24 +90,72 @@ module Llmemory
           { nodes: @graph_storage.count_nodes(uid), edges: @graph_storage.count_edges(uid) }
         end
 
-        # Forgetting a knowledge graph is not a simple delete-by-id: edges are
-        # soft-archived and nodes can be left orphaned. A dedicated graph
-        # edge/node lifecycle (with orphan handling) is a deliberate follow-up.
+        # Forgets relations by archiving the edges identified by the candidate
+        # ids returned from #read/#search_candidates (edge ids), recording the
+        # removal in the audit log. Edges are soft-archived (archived_at) so they
+        # no longer appear in retrieval; nodes are left in place (a node may still
+        # be referenced by other active edges). Returns the number archived.
         def forget(ids:, reason: nil)
-          raise NotImplementedError,
-            "Graph forget is not implemented yet; edge/node lifecycle (archival + orphan handling) is a follow-up."
+          archived = Array(ids).map(&:to_s).select { |edge_id| @kg.archive_edge(edge_id) }
+          forget_log.record(@user_id, memory_type: "graph_based", ids: archived, reason: reason)
+          archived.size
         end
 
         private
 
         def build_vector_store
-          emb = Llmemory::VectorStore::OpenAIEmbeddings.new
-          store_type = (Llmemory.configuration.long_term_store || :memory).to_s.to_sym
-          if store_type == :active_record || store_type == :activerecord
-            require_relative "../../vector_store/active_record_store"
-            Llmemory::VectorStore::ActiveRecordStore.new(embedding_provider: emb)
-          else
-            Llmemory::VectorStore::MemoryStore.new(embedding_provider: emb)
+          Llmemory::VectorStore.build(source_type: "edge")
+        end
+
+        def extract_graph(text)
+          data = @extractor.extract(text) rescue { entities: [], relations: [] }
+          data = { entities: [], relations: [] } unless data.is_a?(Hash)
+          [Array(data[:entities] || data["entities"]), Array(data[:relations] || data["relations"])]
+        end
+
+        # Adds entities and relations to the graph (nodes, edges, embeddings) with
+        # the given provenance. Shared by memorize (conversation) and
+        # remember_fact (reflection).
+        def ingest(entities, relations, provenance)
+          name_to_id = {}
+
+          entities.each do |e|
+            next unless e.is_a?(Hash)
+            entity_type = e[:type] || e["type"] || "concept"
+            name = e[:name] || e["name"]
+            next if name.nil? || name.to_s.strip.empty?
+            id = @kg.add_node(entity_type: entity_type, name: name.to_s.strip, properties: { "provenance" => provenance })
+            name_to_id[name.to_s.strip] ||= id
+          end
+
+          relations.each do |r|
+            next unless r.is_a?(Hash)
+            subject = (r[:subject] || r["subject"]).to_s.strip
+            predicate = (r[:predicate] || r["predicate"]).to_s.strip
+            object = (r[:object] || r["object"]).to_s.strip
+            next if subject.empty? || predicate.empty? || object.empty?
+
+            subject_id = name_to_id[subject] || @kg.add_node(entity_type: "concept", name: subject, properties: { "provenance" => provenance })
+            object_id = name_to_id[object] || @kg.add_node(entity_type: "concept", name: object, properties: { "provenance" => provenance })
+
+            edge = Edge.new(
+              id: nil,
+              user_id: @user_id,
+              subject_id: subject_id,
+              predicate: predicate,
+              target_id: object_id,
+              properties: { "provenance" => provenance },
+              created_at: Time.now,
+              archived_at: nil
+            )
+            @conflict_resolver.resolve(edge)
+            edge_id = @kg.add_edge(subject: subject_id, predicate: predicate, object: object_id, properties: { "provenance" => provenance })
+
+            edge_text = "#{subject} #{predicate} #{object}"
+            embedding = @vector_store.respond_to?(:embed) ? @vector_store.embed(edge_text) : nil
+            if embedding && @vector_store.respond_to?(:store)
+              @vector_store.store(id: edge_id, embedding: embedding, metadata: { text: edge_text, created_at: Time.now }, user_id: @user_id)
+            end
           end
         end
 
@@ -166,7 +183,7 @@ module Llmemory
               subj = @kg.find_node_by_id(e.subject_id)
               obj = @kg.find_node_by_id(e.target_id)
               edge_text = "#{subj&.name} #{e.predicate} #{obj&.name}"
-              out << { id: (e.id ? "edge_#{e.id}" : nil), text: edge_text, score: 0.85, created_at: e.created_at } unless out.any? { |o| o[:text] == edge_text }
+              out << { id: e.id, text: edge_text, score: 0.85, created_at: e.created_at } unless out.any? { |o| o[:text] == edge_text }
             end
           end
 
@@ -179,7 +196,7 @@ module Llmemory
               obj = @kg.find_node_by_id(e.target_id)
               next unless subj && obj
               edge_text = "#{subj.name} #{e.predicate} #{obj.name}"
-              out << { id: (e.id ? "edge_#{e.id}" : nil), text: edge_text, score: 0.7, created_at: e.created_at }
+              out << { id: e.id, text: edge_text, score: 0.7, created_at: e.created_at }
             end
           end
 

data/lib/llmemory/long_term/procedural/memory.rb

@@ -3,6 +3,7 @@
 require_relative "skill"
 require_relative "storage"
 require_relative "../../memory_module"
+require_relative "../../vector_store"
 
 module Llmemory
   module LongTerm
@@ -12,17 +13,20 @@ module Llmemory
       # relevance to the current task, and report outcomes so proven skills are
       # preferred over unproven ones.
       #
-      # Retrieval is keyword-based for now (vector search is a follow-up). The
-      # success rate of each skill is surfaced as `importance`, so the retrieval
-      # Engine ranks battle-tested skills higher (P3 importance weighting).
+      # The success rate of each skill is surfaced as `importance`, so the
+      # retrieval Engine ranks battle-tested skills higher (P3). Semantic
+      # (embedding) retrieval is opt-in via `config.procedural_vector_enabled` or
+      # by injecting a `vector_store:`; when off, search is keyword-only.
       class Memory
         include Llmemory::MemoryModule
 
         attr_reader :user_id, :storage
 
-        def initialize(user_id:, storage: nil)
+        def initialize(user_id:, storage: nil, vector_store: nil)
           @user_id = user_id
           @storage = storage || Storages.build
+          @vector_store = vector_store
+          @vector_explicit = !vector_store.nil?
         end
 
         # Registers a skill. If `version` is omitted and a skill with the same
@@ -33,7 +37,9 @@ module Llmemory
             id: nil, user_id: @user_id, name: name, body: body,
             description: description, kind: kind, version: version
           )
-          @storage.save_skill(@user_id, skill.to_h)
+          id = @storage.save_skill(@user_id, skill.to_h)
+          index_vector(id, skill.searchable_text)
+          id
         end
 
         def find_skill(query)
@@ -62,22 +68,17 @@ module Llmemory
         end
 
         # Retrieval Engine integration: skills ranked by relevance, recency and
-        # proven utility (success rate exposed as importance).
+        # proven utility (success rate exposed as importance). Hybrid (vector +
+        # keyword) when a vector store is active; otherwise keyword-only.
         def search_candidates(query, user_id: nil, top_k: 20)
           uid = user_id || @user_id
           return [] unless uid == @user_id
 
-          @storage.search_skills(uid, query).first(top_k).map do |raw|
-            skill = Skill.from_h(raw)
-            {
-              id: skill.id,
-              text: skill.searchable_text,
-              timestamp: skill.created_at,
-              score: 1.0,
-              importance: skill.success_rate,
-              evergreen: false
-            }
-          end
+          keyword = @storage.search_skills(uid, query).first(top_k).map { |raw| candidate_for(raw, 1.0) }
+          vs = vector_store
+          return keyword unless vs
+
+          merge_candidates(vector_candidates(query, top_k, vs), keyword, top_k)
         end
 
         # --- MemoryModule uniform interface ---
@@ -110,6 +111,59 @@ module Llmemory
           return 1 if existing.empty?
           existing.map { |s| (s[:version] || s["version"] || 1).to_i }.max + 1
         end
+
+        # Active vector store: injected, or a config-gated lazy build; nil when
+        # semantic search is disabled (default).
+        def vector_store
+          if @vector_explicit
+            @vector_store
+          elsif Llmemory.configuration.procedural_vector_enabled
+            @vector_store ||= Llmemory::VectorStore.build(source_type: "skill")
+          end
+        end
+
+        # Best-effort embedding indexing; failures never break registration.
+        def index_vector(id, text)
+          vs = vector_store
+          return if vs.nil? || text.to_s.strip.empty?
+          embedding = vs.embed(text)
+          return unless embedding
+          vs.store(id: id, embedding: embedding, metadata: { text: text, created_at: Time.now }, user_id: @user_id)
+        rescue StandardError
+          nil
+        end
+
+        def vector_candidates(query, top_k, vs)
+          vs.search_by_text(query.to_s, top_k: top_k, user_id: @user_id).filter_map do |r|
+            raw = @storage.get_skill(@user_id, r[:id] || r["id"])
+            raw && candidate_for(raw, (r[:score] || r["score"] || 1.0).to_f)
+          end
+        rescue StandardError
+          []
+        end
+
+        def candidate_for(raw, score)
+          skill = Skill.from_h(raw)
+          {
+            id: skill.id,
+            text: skill.searchable_text,
+            timestamp: skill.created_at,
+            score: score,
+            importance: skill.success_rate,
+            evergreen: false
+          }
+        end
+
+        # Dedup by id keeping the higher score; highest score first, capped.
+        def merge_candidates(primary, secondary, top_k)
+          by_id = {}
+          (primary + secondary).each do |c|
+            key = c[:id] || c[:text]
+            existing = by_id[key]
+            by_id[key] = c if existing.nil? || c[:score].to_f > existing[:score].to_f
+          end
+          by_id.values.sort_by { |c| -c[:score].to_f }.first(top_k)
+        end
       end
     end
   end

data/lib/llmemory/long_term/procedural/storage.rb

@@ -3,6 +3,7 @@
 require_relative "storages/base"
 require_relative "storages/memory_storage"
 require_relative "storages/file_storage"
+require_relative "storages/database_storage"
 
 module Llmemory
   module LongTerm
@@ -11,16 +12,17 @@ module Llmemory
       Storage = Storages::MemoryStorage
 
       module Storages
-        def self.build(store: nil, base_path: nil)
+        def self.build(store: nil, base_path: nil, database_url: nil)
           case (store || Llmemory.configuration.long_term_store).to_s.to_sym
           when :memory
             MemoryStorage.new
           when :file
             FileStorage.new(base_path: base_path || Llmemory.configuration.long_term_storage_path)
-          when :postgres, :database, :active_record, :activerecord
-            raise NotImplementedError,
-              "Procedural SQL/ActiveRecord storage is not implemented yet; use :memory or :file " \
-              "(or pass an explicit storage instance)."
+          when :postgres, :database
+            DatabaseStorage.new(database_url: database_url || Llmemory.configuration.database_url)
+          when :active_record, :activerecord
+            require_relative "storages/active_record_storage"
+            ActiveRecordStorage.new
           else
             MemoryStorage.new
           end

data/lib/llmemory/long_term/procedural/storages/active_record_models.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Model for Procedural ActiveRecordStorage. Loaded only when using
+# store: :active_record. JSONB `data` auto-deserializes to a Hash in Rails 5+.
+
+module Llmemory
+  module LongTerm
+    module Procedural
+      module Storages
+        class LlmemorySkill < ::ActiveRecord::Base
+          self.table_name = "llmemory_skills"
+          self.primary_key = "id"
+        end
+      end
+    end
+  end
+end