llmemory 0.2.0 → 0.2.2

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:)
@@ -100,17 +98,19 @@ module Llmemory
             (@resources.keys + @items.keys + @categories.keys).uniq
           end
 
-          def list_resources(user_id:, limit: nil)
+          def list_resources(user_id:, limit: nil, offset: nil)
             list = @resources[user_id].dup
+            list = list.drop(offset.to_i) if offset && offset.to_i.positive?
             limit ? list.take(limit) : list
           end
 
-          def list_items(user_id:, category: nil, limit: nil)
+          def list_items(user_id:, category: nil, limit: nil, offset: nil)
             list = if category
               @items[user_id].select { |i| i[:category].to_s == category.to_s }
             else
               @items[user_id].dup
             end
+            list = list.drop(offset.to_i) if offset && offset.to_i.positive?
             list = list.take(limit) if limit
             list
           end

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,14 +62,31 @@ 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)
-          memorize(payload)
+          result = nil
+          Llmemory::Instrumentation.instrument(:memory_write, memory_type: "graph_based", user_id: @user_id) do
+            result = memorize(payload)
+          end
+          result
         end
 
-        def list(user_id: nil, limit: nil)
-          @graph_storage.list_nodes(user_id || @user_id, limit: limit)
+        def list(user_id: nil, limit: nil, offset: nil)
+          @graph_storage.list_nodes(user_id || @user_id, limit: limit, offset: offset)
         end
 
         def stats(user_id: nil)
@@ -121,24 +94,76 @@ 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.
-        def forget(ids:, reason: nil)
-          raise NotImplementedError,
-            "Graph forget is not implemented yet; edge/node lifecycle (archival + orphan handling) is a 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, mode: :soft)
+          # `:hard` would physically delete edge rows; not yet wired (the graph
+          # store only exposes soft archive_edge). Both modes route to archive
+          # for now; behavior is the same — kept for API uniformity.
+          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)
+          Llmemory::Instrumentation.instrument(:memory_forget, memory_type: "graph_based", user_id: @user_id, count: archived.size, mode: mode)
+          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 +191,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 +204,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/graph_based/storages/active_record_storage.rb

@@ -52,10 +52,11 @@ module Llmemory
             record_to_node(rec) if rec
           end
 
-          def list_nodes(user_id, entity_type: nil, limit: nil)
+          def list_nodes(user_id, entity_type: nil, limit: nil, offset: nil)
             scope = LlmemoryGraphNode.where(user_id: user_id)
             scope = scope.where(entity_type: entity_type) if entity_type
             scope = scope.limit(limit) if limit && limit.to_i.positive?
+            scope = scope.offset(offset) if offset && offset.to_i.positive?
             scope.map { |r| record_to_node(r) }
           end
 
@@ -106,12 +107,13 @@ module Llmemory
             (LlmemoryGraphNode.distinct.pluck(:user_id) + LlmemoryGraphEdge.distinct.pluck(:user_id)).uniq
           end
 
-          def list_edges(user_id, subject_id: nil, predicate: nil, limit: nil)
+          def list_edges(user_id, subject_id: nil, predicate: nil, limit: nil, offset: nil)
             scope = LlmemoryGraphEdge.where(user_id: user_id, archived_at: nil)
             scope = scope.where(subject_id: subject_id) if subject_id
             scope = scope.where(predicate: predicate) if predicate
             scope = scope.order(created_at: :desc) if limit && limit.to_i.positive?
             scope = scope.limit(limit) if limit && limit.to_i.positive?
+            scope = scope.offset(offset) if offset && offset.to_i.positive?
             scope.map { |r| record_to_edge(r) }
           end
 

data/lib/llmemory/long_term/graph_based/storages/base.rb

@@ -17,7 +17,7 @@ module Llmemory
             raise NotImplementedError, "#{self.class}#find_node_by_name must be implemented"
           end
 
-          def list_nodes(user_id, entity_type: nil, limit: nil)
+          def list_nodes(user_id, entity_type: nil, limit: nil, offset: nil)
             raise NotImplementedError, "#{self.class}#list_nodes must be implemented"
           end
 
@@ -37,7 +37,7 @@ module Llmemory
             raise NotImplementedError, "#{self.class}#list_users must be implemented"
           end
 
-          def list_edges(user_id, subject_id: nil, predicate: nil, limit: nil)
+          def list_edges(user_id, subject_id: nil, predicate: nil, limit: nil, offset: nil)
             raise NotImplementedError, "#{self.class}#list_edges must be implemented"
           end
 

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

@@ -43,9 +43,10 @@ module Llmemory
             @nodes[user_id].values.find { |n| n.entity_type == entity_type.to_s && n.name.to_s == name.to_s }
           end
 
-          def list_nodes(user_id, entity_type: nil, limit: nil)
+          def list_nodes(user_id, entity_type: nil, limit: nil, offset: nil)
             list = @nodes[user_id].values
             list = list.select { |n| n.entity_type.to_s == entity_type.to_s } if entity_type
+            list = list.drop(offset.to_i) if offset && offset.to_i.positive?
             limit ? list.take(limit) : list
           end
 
@@ -106,8 +107,9 @@ module Llmemory
             (@nodes.keys + @edges.keys).uniq
           end
 
-          def list_edges(user_id, subject_id: nil, predicate: nil, limit: nil)
+          def list_edges(user_id, subject_id: nil, predicate: nil, limit: nil, offset: nil)
             list = find_edges(user_id, subject_id: subject_id, predicate: predicate, object_id: nil, include_archived: false)
+            list = list.drop(offset.to_i) if offset && offset.to_i.positive?
             limit ? list.take(limit) : list
           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,28 +13,33 @@ 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
         # name exists, the version auto-increments (skill evolution).
-        def register_skill(name:, body:, description: nil, kind: Skill::DEFAULT_KIND, version: nil)
+        def register_skill(name:, body:, description: nil, kind: Skill::DEFAULT_KIND, version: nil, provenance: nil)
           version ||= next_version_for(name)
           skill = Skill.new(
             id: nil, user_id: @user_id, name: name, body: body,
-            description: description, kind: kind, version: version
+            description: description, kind: kind, version: version, provenance: provenance
           )
-          @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)
@@ -46,8 +52,8 @@ module Llmemory
           raw && Skill.from_h(raw)
         end
 
-        def skills(limit: nil)
-          @storage.list_skills(@user_id, limit: limit).map { |s| Skill.from_h(s) }
+        def skills(limit: nil, offset: nil)
+          @storage.list_skills(@user_id, limit: limit, offset: offset).map { |s| Skill.from_h(s) }
         end
 
         def count
@@ -62,45 +68,53 @@ 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 ---
 
-        def write(name:, body:, description: nil, kind: Skill::DEFAULT_KIND, version: nil, **_meta)
-          register_skill(name: name, body: body, description: description, kind: kind, version: version)
+        def write(name:, body:, description: nil, kind: Skill::DEFAULT_KIND, version: nil, provenance: nil, **_meta)
+          result = nil
+          Llmemory::Instrumentation.instrument(:memory_write, memory_type: "procedural", user_id: @user_id) do
+            result = register_skill(name: name, body: body, description: description, kind: kind, version: version, provenance: provenance)
+          end
+          result
         end
 
-        def list(user_id: nil, limit: nil)
-          skills(limit: limit)
+        def list(user_id: nil, limit: nil, offset: nil)
+          skills(limit: limit, offset: offset)
         end
 
         def stats(user_id: nil)
           { skills: count }
         end
 
-        def forget(ids:, reason: nil)
+        def forget(ids:, reason: nil, mode: :soft)
           requested = Array(ids).map(&:to_s)
           existing = @storage.list_skills(@user_id).map { |s| (s[:id] || s["id"]).to_s }
-          removed = requested & existing
-          @storage.delete_skills(@user_id, removed)
-          forget_log.record(@user_id, memory_type: "procedural", ids: removed, reason: reason)
-          removed.size
+          targeted = requested & existing
+          count = case mode
+          when :hard then @storage.delete_skills(@user_id, targeted).to_i
+          else @storage.archive_skills(@user_id, targeted).to_i
+          end
+          forget_log.record(@user_id, memory_type: "procedural", ids: targeted, reason: reason)
+          Llmemory::Instrumentation.instrument(:memory_forget, memory_type: "procedural", user_id: @user_id, count: count, mode: mode)
+          count
+        end
+
+        # Storage accessor for the TTL maintenance job.
+        def expired_ids(cutoff:)
+          @storage.expired_skill_ids(@user_id, cutoff: cutoff)
         end
 
         private
@@ -110,6 +124,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/skill.rb

@@ -17,10 +17,11 @@ module Llmemory
         DEFAULT_KIND = "prompt"
 
         attr_reader :id, :user_id, :name, :description, :body, :kind, :version,
-                    :success_count, :failure_count, :created_at, :updated_at
+                    :success_count, :failure_count, :provenance, :created_at, :updated_at
 
         def initialize(id:, user_id:, name:, body:, description: nil, kind: DEFAULT_KIND,
-                       version: 1, success_count: 0, failure_count: 0, created_at: nil, updated_at: nil)
+                       version: 1, success_count: 0, failure_count: 0, provenance: nil,
+                       created_at: nil, updated_at: nil)
           @id = id
           @user_id = user_id
           @name = name.to_s
@@ -30,6 +31,7 @@ module Llmemory
           @version = version.to_i
           @success_count = success_count.to_i
           @failure_count = failure_count.to_i
+          @provenance = provenance
           @created_at = created_at || Time.now
           @updated_at = updated_at || @created_at
         end
@@ -60,6 +62,7 @@ module Llmemory
             version: hash[:version] || hash["version"] || 1,
             success_count: hash[:success_count] || hash["success_count"] || 0,
             failure_count: hash[:failure_count] || hash["failure_count"] || 0,
+            provenance: hash[:provenance] || hash["provenance"],
             created_at: parse_time(hash[:created_at] || hash["created_at"]),
             updated_at: parse_time(hash[:updated_at] || hash["updated_at"])
           )
@@ -83,6 +86,7 @@ module Llmemory
             version: version,
             success_count: success_count,
             failure_count: failure_count,
+            provenance: provenance,
             created_at: created_at.respond_to?(:iso8601) ? created_at.iso8601(6) : created_at,
             updated_at: updated_at.respond_to?(:iso8601) ? updated_at.iso8601(6) : updated_at
           }

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