engram 0.7.0 → 0.9.0

data/lib/engram/ports/extractor.rb

@@ -2,13 +2,12 @@
 
 module Engram
   module Ports
-    # PLACEHOLDER (v0.2). Contract for deriving candidate facts from a conversation turn.
-    # Declared now so the differentiator (extract -> consolidate) slots in without
-    # reworking the core. Not implemented in v0.1.
+    # Contract for deriving candidate facts from a conversation turn.
+    # Implementation: Extractors::LLMExtractor.
     module Extractor
       # Given conversation messages, return an Array whose members are Record or Extraction values.
       def extract(messages:, scope:)
-        raise NotImplementedError, "Extractor arrives in v0.2"
+        raise NotImplementedError, "#{self.class} must implement #extract"
       end
     end
   end

data/lib/engram/ports/memory_store.rb

@@ -12,12 +12,13 @@ module Engram
 
       # Return up to `limit` Records in `scope` nearest to `embedding`,
       # ordered most-relevant first. When `kinds` is provided, only records with
-      # those canonical memory kinds are eligible.
+      # those canonical memory kinds are eligible. Exclude expired records before
+      # ordering and limiting; expires_at <= Time.now is expired, nil never expires.
       def search(embedding:, scope:, limit:, kinds: nil, embedding_metadata: nil)
         raise NotImplementedError, "#{self.class} must implement #search"
       end
 
-      # All Records for a scope (mostly for inspection/tests).
+      # All Records for a scope, including expired records (inspection/maintenance).
       # Supports optional `limit` and `offset` for batching large sweeps.
       # Returned records are sorted in stable `id` order when batching is used.
       # Use `after_id` for keyset pagination.
@@ -25,6 +26,12 @@ module Engram
         raise NotImplementedError, "#{self.class} must implement #all"
       end
 
+      # Optional scoped lookup, including expired records, without touching access time.
+      # Returns a Record or nil. Legacy adapters can fall back to #all.
+      def find(scope:, id:)
+        raise NotImplementedError, "#{self.class} does not implement #find"
+      end
+
       # Optional performance capability: return the subset of requested ids that
       # exists in `scope`, preserving each requested value's representation rather
       # than returning a store-native cast of it. Return at most one requested
@@ -49,6 +56,25 @@ module Engram
         raise NotImplementedError, "#{self.class} must implement #delete"
       end
 
+      # Optional bulk deletion: delete the requested IDs that exist in scope and return the
+      # deleted count. Callers fall back to #delete for adapters without it.
+      def delete_many(scope:, ids:)
+        raise NotImplementedError, "#{self.class} does not implement #delete_many"
+      end
+
+      # Optional expiry maintenance: up to `limit` IDs with expires_at <= at,
+      # ordered by ID, strictly after after_id. Never includes nil expiry.
+      def expired_ids(scope:, at:, limit:, after_id: nil)
+        raise NotImplementedError, "#{self.class} does not implement #expired_ids"
+      end
+
+      # Optional expiry maintenance: delete only the requested IDs in scope that
+      # are still expired at the same cutoff. Recheck expiry atomically at deletion
+      # so a concurrent deadline extension is preserved. Returns the deleted count.
+      def delete_expired(scope:, ids:, at:)
+        raise NotImplementedError, "#{self.class} does not implement #delete_expired"
+      end
+
       # Update the last-accessed timestamp of a memory. Used by recency-aware recall.
       # Returns the number of affected rows: 1 when touched, 0 when the scoped record
       # does not exist.

data/lib/engram/rails/has_memory.rb

@@ -22,6 +22,11 @@ module Engram
             if scope_proc
               instance_exec(&scope_proc)
             else
+              unless persisted?
+                raise Engram::Error,
+                  "#{self.class.name} must be saved before using memory, or pass a scope to has_memory"
+              end
+
               "#{self.class.name.underscore}:#{id}"
             end
           Engram::Memory.new(scope: key)

data/lib/engram/rails/tasks.rake

@@ -3,6 +3,36 @@
 # Loaded by the Railtie in Rails apps (where :environment boots the app and its
 # initializers) and by the gem's own Rakefile (which defines a no-op :environment).
 namespace :engram do
+  desc "Delete expired memories in a scope. Usage: bundle exec rake 'engram:forget_expired[user:1]'"
+  task :forget_expired, [:scope] => :environment do |_, args|
+    scope = args[:scope]
+    raise ArgumentError, "forget_expired requires a scope argument" if scope.to_s.empty?
+
+    dry_run = case ENV.fetch("DRY_RUN", "false").downcase
+    when "true", "1", "yes" then true
+    when "false", "0", "no" then false
+    else raise ArgumentError, "DRY_RUN must be true or false"
+    end
+    batch_size = Integer(ENV.fetch("BATCH_SIZE", "100"))
+    result = Engram::Memory.new(scope: scope).forget_expired(batch_size: batch_size, dry_run: dry_run)
+    puts "matched=#{result[:matched]} deleted=#{result[:deleted]} dry_run=#{result[:dry_run]}"
+  end
+
+  desc "Delete every memory in a scope. Usage: bundle exec rake 'engram:forget_all[user:1]'"
+  task :forget_all, [:scope] => :environment do |_, args|
+    scope = args[:scope]
+    raise ArgumentError, "forget_all requires a scope argument" if scope.to_s.empty?
+
+    dry_run = case ENV.fetch("DRY_RUN", "false").downcase
+    when "true", "1", "yes" then true
+    when "false", "0", "no" then false
+    else raise ArgumentError, "DRY_RUN must be true or false"
+    end
+    batch_size = Integer(ENV.fetch("BATCH_SIZE", "100"))
+    result = Engram::Memory.new(scope: scope).forget_all(batch_size: batch_size, dry_run: dry_run)
+    puts "matched=#{result[:matched]} deleted=#{result[:deleted]} dry_run=#{result[:dry_run]}"
+  end
+
   desc "Rebuild embeddings in a memory scope. Usage: bundle exec rake 'engram:rebuild_embeddings[user:1]'"
   task :rebuild_embeddings, [:scope] => :environment do |_, args|
     scope = args[:scope]

data/lib/engram/record.rb

@@ -9,15 +9,18 @@ module Engram
   # `semantic` kind is normalized to `fact` for compatibility with pre-1.0 records.
   class Record
     STATE_READERS = %i[
-      id content scope embedding kind importance metadata created_at last_accessed_at
+      id content scope embedding kind importance metadata created_at last_accessed_at expires_at
     ].freeze
 
     attr_accessor :id, :last_accessed_at
     attr_reader :content, :embedding, :scope, :kind, :importance, :metadata,
-      :created_at
+      :created_at, :expires_at
 
     def initialize(content:, scope:, id: nil, embedding: nil, kind: :fact,
-      importance: 1.0, metadata: {}, created_at: nil, last_accessed_at: nil)
+      importance: 1.0, metadata: {}, created_at: nil, last_accessed_at: nil, expires_at: nil)
+      unless expires_at.nil? || expires_at.is_a?(Time)
+        raise ArgumentError, "expires_at must be a Time or nil"
+      end
       @id = id
       @content = content
       @scope = scope
@@ -27,12 +30,17 @@ module Engram
       @metadata = metadata
       @created_at = created_at || Time.now
       @last_accessed_at = last_accessed_at
+      @expires_at = expires_at&.getutc
     end
 
     def with(**attributes)
       self.class.new(**to_h.merge(attributes))
     end
 
+    def expired?(at: Time.now)
+      !expires_at.nil? && expires_at <= at
+    end
+
     # Return structured supporting-source metadata when this record carries a
     # provenance schema understood by the installed Engram version.
     # Legacy, malformed, and future-schema records remain readable and return nil.

data/lib/engram/use_cases/each_memory.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Engram
+  module UseCases
+    # Yields every memory in a scope in id order, loading at most batch_size records at a time.
+    # Stores whose #all does not accept limit/after_id are read in one call.
+    class EachMemory
+      def initialize(store:)
+        @store = store
+      end
+
+      def call(scope:, batch_size: 100, &block)
+        unless batch_size.is_a?(Integer) && batch_size.positive?
+          raise ArgumentError, "batch_size must be a positive integer"
+        end
+        unless keyset_supported?
+          sort_by_id(@store.all(scope: scope)).each(&block)
+          return nil
+        end
+
+        after_id = nil
+        loop do
+          batch = @store.all(scope: scope, limit: batch_size, after_id: after_id)
+          break if batch.empty?
+          unless batch.size <= batch_size && advances?(batch.map(&:id), after_id)
+            raise Engram::Error, "store #all must return pages that advance by id"
+          end
+
+          batch.each(&block)
+          after_id = batch.last.id
+        end
+        nil
+      end
+
+      private
+
+      def advances?(ids, after_id)
+        ids = [after_id, *ids] unless after_id.nil?
+        ids.none?(&:nil?) && ids.each_cons(2).all? { |previous, current| previous < current }
+      rescue ArgumentError, NoMethodError
+        false
+      end
+
+      def sort_by_id(records)
+        records.sort_by(&:id)
+      rescue ArgumentError, NoMethodError
+        raise Engram::Error, "store #all returned ids that cannot be ordered"
+      end
+
+      def keyset_supported?
+        keywords = @store.method(:all).parameters.filter_map { |kind, name| name if %i[key keyreq].include?(kind) }
+        keywords.include?(:limit) && keywords.include?(:after_id)
+      end
+    end
+  end
+end

data/lib/engram/use_cases/forget_all.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Engram
+  module UseCases
+    # Deletes every memory in a scope in id-ordered batches. Like Memory#forget, it bypasses
+    # extraction, consolidation, and persistence hooks.
+    class ForgetAll
+      def initialize(store:)
+        @store = store
+      end
+
+      def call(scope:, batch_size: 100, dry_run: false)
+        unless batch_size.is_a?(Integer) && batch_size.positive?
+          raise ArgumentError, "batch_size must be a positive integer"
+        end
+        unless dry_run.equal?(true) || dry_run.equal?(false)
+          raise ArgumentError, "dry_run must be true or false"
+        end
+
+        counts = {matched: 0, deleted: 0, dry_run: dry_run}
+        payload = Engram::Instrumentation.payload(scope: scope, store: @store, **counts)
+        Engram::Instrumentation.instrument("forget_all", payload) do
+          ids = []
+          flush = lambda do
+            counts[:matched] += ids.size
+            payload.merge!(counts)
+            unless dry_run
+              delete(scope, ids) do |deleted|
+                counts[:deleted] += deleted
+                payload.merge!(counts)
+              end
+            end
+            ids = []
+          end
+          EachMemory.new(store: @store).call(scope: scope, batch_size: batch_size) do |record|
+            ids << record.id
+            flush.call if ids.size == batch_size
+          end
+          flush.call unless ids.empty?
+          counts
+        end
+      end
+
+      private
+
+      def delete(scope, ids)
+        if @store.respond_to?(:delete_many)
+          begin
+            return yield @store.delete_many(scope: scope, ids: ids)
+          rescue NotImplementedError
+            # Optional capability: legacy adapters may inherit the default stub.
+          end
+        end
+
+        ids.each { |id| yield @store.delete(scope: scope, id: id).to_i }
+      end
+    end
+  end
+end

data/lib/engram/use_cases/forget_expired.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Engram
+  module UseCases
+    # Deletes expired memories in bounded batches using one cutoff for the whole run.
+    class ForgetExpired
+      def initialize(store:)
+        @store = store
+      end
+
+      def call(scope:, batch_size: 100, dry_run: false, now: Time.now)
+        unless batch_size.is_a?(Integer) && batch_size.positive?
+          raise ArgumentError, "batch_size must be a positive integer"
+        end
+        unless dry_run.equal?(true) || dry_run.equal?(false)
+          raise ArgumentError, "dry_run must be true or false"
+        end
+        unless @store.respond_to?(:expired_ids) && @store.respond_to?(:delete_expired)
+          raise Engram::Error, "forget_expired requires a store implementing expired_ids and delete_expired"
+        end
+
+        counts = {matched: 0, deleted: 0, dry_run: dry_run}
+        payload = Engram::Instrumentation.payload(scope: scope, store: @store, **counts)
+        Engram::Instrumentation.instrument("forget_expired", payload) do
+          after_id = nil
+          loop do
+            ids = @store.expired_ids(scope: scope, at: now, limit: batch_size, after_id: after_id)
+            break if ids.empty?
+            raise Engram::Error, "expired_ids must advance its cursor" if ids.last == after_id
+
+            counts[:matched] += ids.length
+            counts[:deleted] += @store.delete_expired(scope: scope, ids: ids, at: now) unless dry_run
+            payload.merge!(counts)
+            after_id = ids.last
+          end
+          counts
+        end
+      rescue NotImplementedError
+        raise Engram::Error, "forget_expired requires a store implementing expired_ids and delete_expired"
+      end
+    end
+  end
+end

data/lib/engram/use_cases/inject.rb

@@ -31,7 +31,10 @@ module Engram
           suffix = "\n</engram-memories>"
           bytes = prefix.bytesize + suffix.bytesize
           lines = []
+          now = Time.now
           memories.each do |memory|
+            next if memory.expired?(at: now)
+
             line = render_memory(memory)
             added_bytes = line.bytesize + (lines.empty? ? 0 : 1)
             next if max_bytes && bytes + added_bytes > max_bytes

data/lib/engram/use_cases/recall.rb

@@ -57,10 +57,10 @@ module Engram
             kinds: kinds
           )
 
-          candidates = if min_similarity.nil?
-            pool
-          else
-            pool.select { |record| meets_similarity?(record.embedding, embedding, min_similarity) }
+          now = Time.now
+          candidates = pool.select do |record|
+            !record.expired?(at: now) &&
+              (min_similarity.nil? || meets_similarity?(record.embedding, embedding, min_similarity))
           end
           results = (reranking? ? rerank(candidates, embedding) : candidates).first(limit)
           touch(results, scope) if @touch

data/lib/engram/use_cases/update.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Engram
+  module UseCases
+    # Scoped read/merge/write correction. Concurrent writers require host coordination.
+    class Update
+      def initialize(store:, embedder:)
+        @store = store
+        @embedder = embedder
+      end
+
+      def call(scope:, id:, attributes:)
+        attributes = validate_attributes!(id, attributes)
+        payload = Engram::Instrumentation.payload(scope: scope, store: @store,
+          fields: attributes.keys.map(&:to_s), content_changed: false, reembedded: false)
+        Engram::Instrumentation.instrument("update", payload) do
+          original = find(scope, id)
+          unless original && Engram::Internal::Scope.record_matches?(original, scope)
+            payload[:outcome] = "missing"
+            raise Engram::MemoryNotFoundError, "no memory in this scope"
+          end
+
+          # Validate before any edit can remove inherited evidence.
+          Engram::Provenance.canonical_payload_for_persistence(original.metadata)
+          original = detach(plain_times(original))
+          original = original.with(metadata: Engram::Provenance.canonical_metadata_for_persistence(original.metadata))
+          persistence = Engram::Persistence.new(store: @store, embedder: @embedder)
+          unless persistence.allowed?(detach(original))
+            payload[:outcome] = "rejected"
+            next nil
+          end
+
+          candidate = merge(original, attributes)
+          candidate = invalidate_provenance(candidate, original)
+          payload[:content_changed] = candidate.content != original.content
+          evidence = provenance(candidate)
+          candidate = persistence.transform(candidate) do |transformed|
+            validate_transformation!(transformed, original, scope)
+            unless provenance(transformed) == evidence
+              raise Engram::Error, "update transformations cannot change provenance trust"
+            end
+            transformed = invalidate_provenance(transformed, original)
+            evidence = provenance(transformed)
+            payload[:content_changed] = transformed.content != original.content
+            transformed
+          end
+          unless candidate
+            payload[:outcome] = "rejected"
+            next nil
+          end
+
+          payload[:content_changed] = candidate.content != original.content
+          candidate = replace_reserved_field(candidate, "embedding")
+          if payload[:content_changed] || original.embedding.nil?
+            candidate = candidate.with(embedding: @embedder.embed(candidate.content))
+            payload[:reembedded] = true
+            candidate = Engram::EmbeddingMetadata.attach(candidate, embedder: @embedder)
+          else
+            candidate = replace_reserved_field(candidate, "embedding", source: original)
+              .with(embedding: original.embedding)
+          end
+          candidate = candidate.with(created_at: original.created_at, last_accessed_at: original.last_accessed_at)
+          stored = persistence.update_prepared(scope: scope, id: id, record: candidate)
+          payload[:outcome] = "updated"
+          stored
+        end
+      end
+
+      private
+
+      def validate_attributes!(id, attributes)
+        valid_id = id.instance_of?(Integer) || (id.instance_of?(String) && id.valid_encoding? && !id.strip.empty?)
+        raise ArgumentError, "id must be an Integer or a non-empty String" unless valid_id
+        raise ArgumentError, "at least one attribute must be supplied" if attributes.empty?
+
+        attributes = attributes.dup
+        attributes.each do |field, value|
+          valid = case field
+          when :content
+            value.is_a?(String) && value.valid_encoding? && !value.strip.empty?
+          when :kind
+            attributes[field] = Engram::MemoryKind.normalize(value)
+            true
+          when :importance
+            (value.is_a?(Integer) || value.is_a?(Float)) && value.finite?
+          when :metadata
+            value.is_a?(Hash) && !reserved_metadata?(value)
+          when :expires_at
+            value.nil? || value.is_a?(Time)
+          else
+            false
+          end
+          raise ArgumentError, "invalid #{field}" unless valid
+        end
+        attributes
+      end
+
+      def reserved_metadata?(metadata)
+        Engram::Internal::CoreHash.each_pair(metadata) do |key, _|
+          return true if key.equal?(:_engram)
+          return true if key.is_a?(String) && String.instance_method(:==).bind_call(key, "_engram")
+        end
+        false
+      end
+
+      def find(scope, id)
+        if @store.respond_to?(:find)
+          begin
+            return @store.find(scope: scope, id: id)
+          rescue NotImplementedError
+            # Optional capability: legacy adapters may inherit the default stub.
+          end
+        end
+        @store.all(scope: scope).find { |record| record.id == id }
+      end
+
+      def detach(record)
+        Engram::Internal::CandidateIntegrity.new.detach(record)
+      rescue Engram::Internal::CandidateIntegrity::Error => error
+        raise Engram::Error, error.message
+      end
+
+      # Rails stores return ActiveSupport::TimeWithZone; candidates accept only plain Time.
+      def plain_times(record)
+        record.with(
+          created_at: plain_time(record.created_at),
+          last_accessed_at: plain_time(record.last_accessed_at),
+          expires_at: plain_time(record.expires_at)
+        )
+      end
+
+      def plain_time(value)
+        (value.nil? || value.instance_of?(Time)) ? value : Time.at(value.to_r).utc
+      end
+
+      def merge(original, attributes)
+        if attributes.key?(:metadata)
+          metadata = Hash.instance_method(:transform_values).bind_call(attributes[:metadata]) { |value| value }
+          ["_engram", :_engram].each do |key|
+            metadata[key] = original.metadata[key] if original.metadata.key?(key)
+          end
+          attributes = attributes.merge(metadata: metadata)
+        end
+        detach(original.with(**attributes))
+      end
+
+      def provenance(record)
+        Engram::Provenance.canonical_integrity_representation_for_persistence(record.metadata)
+      end
+
+      def invalidate_provenance(record, original)
+        return record if record.content == original.content
+
+        replace_reserved_field(record, "provenance")
+      end
+
+      # Keep unrelated reserved siblings and preserve the stored embedding schema
+      # exactly when reusing its vector, including legacy symbol-key aliases.
+      def replace_reserved_field(record, field, source: nil)
+        metadata = record.metadata.dup
+        ["_engram", :_engram].each do |key|
+          reserved = metadata[key]&.dup || {}
+          reserved.delete(field)
+          reserved.delete(field.to_sym)
+          inherited = source&.metadata&.fetch(key, {}) || {}
+          [field, field.to_sym].each do |alias_key|
+            reserved[alias_key] = inherited[alias_key] if inherited.key?(alias_key)
+          end
+          metadata[key] = reserved if metadata.key?(key) || !reserved.empty?
+        end
+        record.with(metadata: metadata)
+      end
+
+      def validate_transformation!(record, original, scope)
+        unless Engram::Internal::Scope.record_matches?(record, scope) && record.id == original.id
+          raise Engram::Error, "update transformations cannot change memory identity or scope"
+        end
+        validate_attributes!(record.id,
+          content: record.content, kind: record.kind, importance: record.importance, expires_at: record.expires_at)
+      rescue ArgumentError => error
+        raise Engram::Error, error.message
+      end
+    end
+  end
+end

data/lib/engram/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Engram
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

data/lib/engram.rb

@@ -31,6 +31,10 @@ require_relative "engram/use_cases/recall"
 require_relative "engram/use_cases/inject"
 require_relative "engram/use_cases/observe"
 require_relative "engram/use_cases/forget"
+require_relative "engram/use_cases/update"
+require_relative "engram/use_cases/each_memory"
+require_relative "engram/use_cases/forget_all"
+require_relative "engram/use_cases/forget_expired"
 require_relative "engram/use_cases/rebuild_embeddings"
 require_relative "engram/use_cases/source_impact"
 require_relative "engram/use_cases/grounding_report"
@@ -64,6 +68,9 @@ module Engram
   # Raised when a live claim suppresses an observation that has not completed.
   class ObservationInProgressError < Error; end
 
+  # Raised when a correction targets a memory absent from the caller's scope.
+  class MemoryNotFoundError < Error; end
+
   class << self
     def config
       @config ||= Configuration.new

data/lib/generators/engram/expiry_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Engram
+  module Generators
+    # Adds expiry to a table created by Engram 0.7 or earlier.
+    class ExpiryGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def create_migration_file
+        migration_template "add_expiry_to_engram_memories.rb.tt",
+          "db/migrate/add_expiry_to_engram_memories.rb"
+      end
+
+      def self.next_migration_number(dir)
+        ::ActiveRecord::Generators::Base.next_migration_number(dir)
+      end
+
+      private
+
+      def migration_version
+        "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}"
+      end
+    end
+  end
+end

data/lib/generators/engram/install_generator.rb

@@ -44,6 +44,12 @@ module Engram
         options[:dimensions]
       end
 
+      def embedder_arguments
+        return "" if dimensions == DEFAULT_DIMENSIONS
+
+        "(dimensions: #{dimensions})"
+      end
+
       def validate_dimensions!
         return if dimensions.is_a?(Integer) && dimensions.positive?
 

data/lib/generators/engram/templates/add_expiry_to_engram_memories.rb.tt

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddExpiryToEngramMemories < ActiveRecord::Migration[<%= migration_version %>]
+  disable_ddl_transaction!
+
+  def change
+    add_column :engram_memories, :expires_at, :datetime
+    add_index :engram_memories, [:scope, :expires_at],
+      name: "index_engram_memories_on_scope_and_expiry",
+      where: "expires_at IS NOT NULL", algorithm: :concurrently
+  end
+end

data/lib/generators/engram/templates/create_engram_memories.rb.tt

@@ -12,11 +12,15 @@ class CreateEngramMemories < ActiveRecord::Migration[<%= migration_version %>]
       t.jsonb :metadata, null: false, default: {}
       t.vector :embedding, limit: <%= dimensions %>
       t.datetime :last_accessed_at
+      t.datetime :expires_at
 
       t.timestamps
     end
 
     add_index :engram_memories, :scope
+    add_index :engram_memories, [:scope, :expires_at],
+      name: "index_engram_memories_on_scope_and_expiry",
+      where: "expires_at IS NOT NULL"
 
     # For larger datasets, choose one approximate vector index after backfilling data.
     # HNSW is a strong default for read-heavy recall workloads with frequent inserts.

data/lib/generators/engram/templates/initializer.rb.tt

@@ -5,7 +5,8 @@ Engram.configure do |config|
   config.store = Engram::Adapters::PgvectorStore.new
 
   # Generate embeddings via RubyLLM. Configure RubyLLM separately with your provider keys.
-  config.embedder = Engram::Adapters::RubyLLMEmbedder.new
+  # The embedder must return <%= dimensions %>-dimensional vectors to match the migration.
+  config.embedder = Engram::Adapters::RubyLLMEmbedder.new<%= embedder_arguments %>
 
   # How many memories to recall by default.
   config.default_limit = 5