embed_sync 0.1.0

data/lib/embed_sync/providers/ruby_llm.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module EmbedSync
+  module Providers
+    # Generates embeddings with the ruby_llm gem (OpenAI, Gemini, Voyage, Bedrock, Ollama, ...).
+    # API keys are configured through RubyLLM.configure, not here.
+    #
+    #   EmbedSync.config.provider = :ruby_llm
+    #   EmbedSync.config.provider_options = { dimensions: 512, provider: :openai }
+    class RubyLLM < Base
+      EMBED_OPTIONS = %i[dimensions provider assume_model_exists task_type provider_options].freeze
+      INVALID_REQUEST_ERRORS = %w[BadRequestError ContextLengthExceededError UnauthorizedError ForbiddenError
+                                  PaymentRequiredError ContentFilterError ModelNotFoundError].freeze
+
+      def initialize(**options)
+        super()
+        unknown = options.keys - EMBED_OPTIONS
+        raise ConfigurationError, "Unknown ruby_llm provider options: #{unknown.join(", ")}" if unknown.any?
+
+        @options = options.compact
+        load_ruby_llm
+      end
+
+      def embed(texts, model:)
+        vectors = ::RubyLLM.embed(texts, model: model, **@options).vectors
+        # RubyLLM returns a flat vector when it embedded a single text.
+        vectors.first.is_a?(Numeric) ? [vectors] : vectors
+      rescue *invalid_request_errors => e
+        raise InvalidRequestError, "#{e.class}: #{e.message}"
+      rescue *retryable_errors => e
+        raise ProviderError, "#{e.class}: #{e.message}"
+      end
+
+      private
+
+      # The request itself was rejected; sending it again gives the same answer.
+      def invalid_request_errors
+        INVALID_REQUEST_ERRORS.filter_map do |name|
+          ::RubyLLM.const_get(name, false) if ::RubyLLM.const_defined?(name, false)
+        end
+      end
+
+      # Everything else from the API (rate limits, 5xx, overloaded) plus network failures, which ruby_llm
+      # lets through from Faraday.
+      def retryable_errors
+        [::RubyLLM::Error, (::Faraday::Error if defined?(::Faraday::Error))].compact
+      end
+
+      def load_ruby_llm
+        require "ruby_llm" unless defined?(::RubyLLM.embed)
+      rescue LoadError
+        raise ConfigurationError, 'The :ruby_llm provider needs the ruby_llm gem. Add gem "ruby_llm" to your Gemfile.'
+      end
+    end
+  end
+end

data/lib/embed_sync/providers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module EmbedSync
+  # Registry of embedding providers, looked up by name.
+  module Providers
+    @registry = {}
+
+    class << self
+      # The class is given as a string so a provider's dependencies only load when it is used.
+      def register(name, class_name)
+        @registry[name.to_sym] = class_name
+      end
+
+      def registered
+        @registry.keys
+      end
+
+      def build(name, **)
+        class_name = @registry.fetch(name.to_sym) do
+          raise ConfigurationError,
+                "Unknown provider #{name.inspect}. Registered providers: #{registered.join(", ")}"
+        end
+        require_relative "providers/ruby_llm" if class_name == "EmbedSync::Providers::RubyLLM"
+        Object.const_get(class_name).new(**)
+      end
+    end
+  end
+end
+
+require_relative "providers/base"
+require_relative "providers/fake"
+
+EmbedSync::Providers.register(:fake, "EmbedSync::Providers::Fake")
+EmbedSync::Providers.register(:ruby_llm, "EmbedSync::Providers::RubyLLM")

data/lib/embed_sync/query.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module EmbedSync
+  # Embeds search queries, optionally caching them (config.query_cache = Rails.cache).
+  module Query
+    module_function
+
+    def embed(text, definition)
+      raise ArgumentError, "Search query can't be blank" if text.blank?
+
+      cache = EmbedSync.config.query_cache
+      return embed_now(text, definition) unless cache
+
+      cache.fetch(cache_key(text, definition), expires_in: EmbedSync.config.query_cache_expires_in) do
+        embed_now(text, definition)
+      end
+    end
+
+    def embed_now(text, definition)
+      Sync.embed_texts([text.to_s], definition).first
+    end
+
+    def cache_key(text, definition)
+      "embed_sync/query/#{definition.model_name}/#{definition.dimensions}/#{Digest::SHA256.hexdigest(text.to_s)}"
+    end
+  end
+end

data/lib/embed_sync/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module EmbedSync
+  # Hooks EmbedSync into Rails: rake tasks, logging and job settings.
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path("tasks/embed_sync.rake", __dir__)
+    end
+
+    initializer "embed_sync.log_subscriber" do
+      require_relative "log_subscriber"
+    end
+
+    config.after_initialize do
+      limit = EmbedSync.config.concurrency_limit
+      EmbedSync::EmbedJob.apply_concurrency_limit(limit) if limit
+    end
+  end
+end

data/lib/embed_sync/sync.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module EmbedSync
+  # Embeds a batch of records for one has_embedding column with a single provider call.
+  module Sync
+    module_function
+
+    # Returns the number of records written. Fresh records are skipped unless force: true.
+    # Records with blank source text get a nil vector without calling the provider.
+    # skip_invalid: records the provider rejects (e.g. text too long) are left stale instead of raising.
+    # recheck: before writing, reload the record under a row lock and skip it if its text changed while the
+    # provider was working (the save that changed it queues its own embedding).
+    def call(records, column, force: false, skip_invalid: false, recheck: false)
+      return 0 if records.empty?
+
+      definition = records.first.class.embed_sync_definition(column)
+      pending = pending_records(records, definition, force)
+      return 0 if pending.empty?
+
+      vectors = embed_pending(pending.map(&:last), definition, skip_invalid)
+      pending.zip(vectors).count do |(record, text), vector|
+        vector != :rejected && write(record, definition, text, vector, recheck)
+      end
+    end
+
+    def pending_records(records, definition, force)
+      records.filter_map do |record|
+        [record, definition.source_text(record)] if force || definition.stale?(record)
+      end
+    end
+
+    # One provider call for the whole batch. If the provider rejects it, embed the texts one at a time so
+    # a single bad record doesn't block the others; the rejected ones come back as :rejected.
+    def embed_pending(texts, definition, skip_invalid)
+      embed_with_blanks(texts, definition)
+    rescue InvalidRequestError
+      raise unless skip_invalid
+      return [:rejected] if texts.one?
+
+      texts.map { |text| embed_pending([text], definition, skip_invalid).first }
+    end
+
+    # Blank texts get nil without being sent to the provider.
+    def embed_with_blanks(texts, definition)
+      vectors = embed_texts(texts.select(&:present?), definition).each
+      texts.map { |text| text.present? ? vectors.next : nil }
+    end
+
+    def write(record, definition, text, vector, recheck)
+      attributes = { definition.column => vector, definition.digest_column => definition.digest(text) }
+      return record.update_columns(attributes) unless recheck
+
+      record.with_lock do
+        next false unless definition.source_text(record) == text
+
+        record.update_columns(attributes)
+      end
+    end
+
+    def embed_texts(texts, definition)
+      return [] if texts.empty?
+
+      vectors = instrument(texts, definition) { EmbedSync.provider.embed(texts, model: definition.model_name) }
+      unless vectors.is_a?(Array) && vectors.size == texts.size
+        raise ProviderError, "Expected #{texts.size} vectors from the provider, got #{vectors.try(:size).inspect}"
+      end
+
+      check_dimensions!(vectors, definition)
+
+      vectors
+    end
+
+    def check_dimensions!(vectors, definition)
+      return unless definition.dimensions
+
+      wrong = vectors.find { |vector| vector.size != definition.dimensions }
+      return unless wrong
+
+      raise DimensionMismatchError, "#{definition.column} expects #{definition.dimensions} dimensions, " \
+                                    "but #{definition.model_name} returned #{wrong.size}"
+    end
+
+    # Publishes "embed.embed_sync" with record_class, column, model and count (and exception, if raised).
+    def instrument(texts, definition, &)
+      payload = { record_class: definition.owner&.name, column: definition.column,
+                  model: definition.model_name, count: texts.size }
+      ActiveSupport::Notifications.instrument("embed.embed_sync", payload, &)
+    end
+  end
+end

data/lib/embed_sync/tasks/embed_sync.rake

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+namespace :embed_sync do
+  find_models = lambda do |name|
+    if name.present?
+      [name.constantize]
+    else
+      Rails.application.eager_load! if defined?(Rails.application)
+      ActiveRecord::Base.descendants.select { |klass| klass.embed_sync_definitions.any? && !klass.abstract_class? }
+    end
+  end
+
+  # Without a model name, each embedding is visited once, on the class that declared it: STI subclasses
+  # inherit their parent's has_embedding and their rows are already covered by the parent's table scan.
+  each_embedding = lambda do |args, &block|
+    explicit = args[:model].present?
+    find_models.call(args[:model]).each do |model|
+      definitions = model.embed_sync_definitions.values
+      definitions = definitions.select { |d| d.column.to_s == args[:column].to_s } if args[:column].present?
+      definitions = definitions.select { |d| d.owner == model } unless explicit
+      if explicit && definitions.empty?
+        raise ArgumentError, "#{model.name} has no has_embedding for #{args[:column].inspect}"
+      end
+
+      definitions.each { |definition| block.call(model, definition.column) }
+    end
+  end
+
+  desc "Embed records that are missing or out of date. Usage: embed_sync:backfill[Product,embedding]"
+  task :backfill, %i[model column] => :environment do |_task, args|
+    each_embedding.call(args) do |model, column|
+      count = EmbedSync::Backfill.run(model, column: column) { |total| print "\r#{model.name}##{column}: #{total}" }
+      puts "\r#{model.name}##{column}: embedded #{count} records"
+    end
+  end
+
+  desc "Report records whose embedding is missing or out of date. Usage: embed_sync:stale[Product,embedding]"
+  task :stale, %i[model column] => :environment do |_task, args|
+    each_embedding.call(args) do |model, column|
+      report = EmbedSync::Backfill.report(model, column: column)
+      puts "#{model.name}##{column}: #{report[:total]} total, #{report[:missing]} never embedded, " \
+           "#{report[:stale]} stale"
+    end
+  end
+end

data/lib/embed_sync/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EmbedSync
+  VERSION = "0.1.0"
+end

data/lib/embed_sync.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/lazy_load_hooks"
+require "active_support/isolated_execution_state"
+
+require_relative "embed_sync/version"
+require_relative "embed_sync/errors"
+require_relative "embed_sync/configuration"
+require_relative "embed_sync/providers"
+require_relative "embed_sync/definition"
+require_relative "embed_sync/sync"
+require_relative "embed_sync/backfill"
+require_relative "embed_sync/query"
+
+# Keeps vector embeddings in sync with ActiveRecord models.
+module EmbedSync
+  autoload :Model, "embed_sync/model"
+  autoload :EmbedJob, "embed_sync/embed_job"
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+
+    def reset_config!
+      @config = nil
+    end
+
+    def provider
+      config.resolved_provider
+    end
+
+    # Turns off automatic syncing inside the block (e.g. bulk imports), on this thread only.
+    def without_sync
+      previous = ActiveSupport::IsolatedExecutionState[:embed_sync_disabled]
+      ActiveSupport::IsolatedExecutionState[:embed_sync_disabled] = true
+      yield
+    ensure
+      ActiveSupport::IsolatedExecutionState[:embed_sync_disabled] = previous
+    end
+
+    def sync_enabled?
+      !ActiveSupport::IsolatedExecutionState[:embed_sync_disabled]
+    end
+
+    # EmbedSync.backfill(Product) / EmbedSync.backfill(Product.includes(:category), column: :embedding)
+    def backfill(scope, **, &)
+      Backfill.run(scope, **, &)
+    end
+
+    def stale_report(scope, **)
+      Backfill.report(scope, **)
+    end
+
+    # Called after commit: queues or runs the embedding when the record's text changed.
+    def sync_record(record, column)
+      return if !sync_enabled? || record.embed_sync_skipped?
+
+      definition = record.class.embed_sync_definition(column)
+      record = full_record(record, definition) or return
+      return unless definition.stale?(record)
+
+      case definition.sync_mode
+      when :async then EmbedJob.perform_later(record, column.to_s)
+      when :inline then sync_inline(record, column)
+      end
+    end
+
+    private
+
+    # Records loaded with select(...) may lack the columns stale? reads; load the whole row instead.
+    def full_record(record, definition)
+      definition.stale?(record)
+      record
+    rescue ActiveModel::MissingAttributeError
+      record.class.unscoped.find_by(record.class.primary_key => record.id)
+    end
+
+    # The row is already committed, so a provider failure must not make save look like it failed.
+    # The error is logged by EmbedSync::LogSubscriber and the record stays stale for embed_sync:backfill.
+    def sync_inline(record, column)
+      Sync.call([record], column, recheck: true)
+    rescue ProviderError, InvalidRequestError
+      nil
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include EmbedSync::Model
+end
+
+require_relative "embed_sync/railtie" if defined?(Rails::Railtie)

data/lib/generators/embed_sync/embed_sync_generator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+require "rails/generators/active_record"
+
+module EmbedSync
+  module Generators
+    # rails g embed_sync Product name description [--column=embedding] [--dimensions=1536]
+    class EmbedSyncGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      OPCLASSES = { "cosine" => "vector_cosine_ops", "euclidean" => "vector_l2_ops",
+                    "inner_product" => "vector_ip_ops" }.freeze
+
+      namespace "embed_sync"
+      source_root File.expand_path("templates", __dir__)
+      desc "Adds an embedding column, digest column and vector index to a model (PostgreSQL + pgvector)"
+
+      argument :source_attributes, type: :array, default: [], banner: "attribute attribute"
+
+      class_option :column, type: :string, default: "embedding", desc: "Vector column name"
+      class_option :dimensions, type: :numeric, default: 1536, desc: "Vector size of your embedding model"
+      class_option :index, type: :string, default: "hnsw", enum: %w[hnsw ivfflat none], desc: "Vector index type"
+      class_option :distance, type: :string, default: "cosine", enum: OPCLASSES.keys, desc: "Distance for the index"
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def check_source_attributes
+        return if source_attributes.any?
+
+        raise Thor::Error, "Pass the attributes to embed, e.g. rails g embed_sync #{class_name} name description"
+      end
+
+      def create_migration_file
+        migration_template "migration.rb.tt", "db/migrate/add_#{column}_to_#{table_name}.rb"
+      end
+
+      def add_has_embedding_to_model
+        path = File.join("app/models", class_path, "#{file_name}.rb")
+        unless File.exist?(File.join(destination_root, path))
+          say_status :skip, "#{path} not found; add has_embedding to your model yourself", :yellow
+          return
+        end
+
+        # Matches both `class Admin::Product` and `module Admin; class Product`.
+        source = File.read(File.join(destination_root, path))
+        name = source.match?(/class\s+#{Regexp.escape(class_name)}\b/) ? class_name : class_name.demodulize
+        inject_into_class path, name, model_lines
+      end
+
+      # Without neighbor, Rails doesn't know the vector type: it drops limit:, the index fails and
+      # schema.rb can't dump the table.
+      def warn_without_neighbor
+        return if defined?(::Neighbor)
+
+        say_status :warning, 'Add gem "neighbor" to your Gemfile before running this migration ' \
+                             "(it teaches Rails the pgvector column type).", :yellow
+      end
+
+      private
+
+      def column
+        options[:column]
+      end
+
+      def index?
+        options[:index] != "none"
+      end
+
+      def opclass
+        OPCLASSES.fetch(options[:distance])
+      end
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def model_lines
+        from = source_attributes.one? ? ":#{source_attributes.first}" : "%i[#{source_attributes.join(" ")}]"
+        lines = []
+        lines << "  has_neighbors :#{column}\n" if defined?(::Neighbor)
+        lines << "  has_embedding :#{column}, from: #{from}\n"
+        lines.join
+      end
+    end
+  end
+end

data/lib/generators/embed_sync/install_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module EmbedSync
+  module Generators
+    # rails g embed_sync:install
+    class InstallGenerator < Rails::Generators::Base
+      namespace "embed_sync:install"
+      source_root File.expand_path("templates", __dir__)
+      desc "Creates config/initializers/embed_sync.rb"
+
+      def create_initializer
+        template "initializer.rb.tt", "config/initializers/embed_sync.rb"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+EmbedSync.configure do |config|
+  # Service that generates embeddings: a registered name or any object that responds to
+  # #embed(texts, model:).
+  #   :ruby_llm  uses the ruby_llm gem; set API keys with RubyLLM.configure (e.g. config.openai_api_key)
+  #   :fake      deterministic vectors, never calls an API (good for tests)
+  config.provider = Rails.env.test? ? :fake : :ruby_llm
+  # Passed to RubyLLM.embed: dimensions:, provider:, assume_model_exists:, task_type:, provider_options:
+  # config.provider_options = { dimensions: 1536 }
+
+  # Embedding model used when has_embedding doesn't pass model:.
+  config.default_model = "text-embedding-3-small"
+
+  # :async (enqueue EmbedSync::EmbedJob after commit), :inline (embed during the commit) or false.
+  config.sync = Rails.env.test? ? false : :async
+
+  # Active Job queue for EmbedSync::EmbedJob.
+  config.queue = :default
+
+  # Records per provider call when backfilling.
+  config.batch_size = 100
+end

data/lib/generators/embed_sync/templates/migration.rb.tt

@@ -0,0 +1,12 @@
+class Add<%= column.camelize %>To<%= table_name.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    # Guarded so rolling back this migration doesn't try to drop the extension other vector columns use.
+    enable_extension "vector" unless extension_enabled?("vector")
+
+    add_column :<%= table_name %>, :<%= column %>, :vector, limit: <%= options[:dimensions] %>
+    add_column :<%= table_name %>, :<%= column %>_digest, :string
+<% if index? -%>
+    add_index :<%= table_name %>, :<%= column %>, using: :<%= options[:index] %>, opclass: :<%= opclass %>
+<% end -%>
+  end
+end

data/sig/embed_sync.rbs

@@ -0,0 +1,4 @@
+module EmbedSync
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: embed_sync
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Umair0092
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: Declare which attributes an ActiveRecord model embeds, and EmbedSync
+  regenerates the vector in a background job whenever that text changes. Includes
+  change detection, backfill and stale-record tasks, and pluggable providers.
+email:
+- umairhassan0092@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/embed_sync.rb
+- lib/embed_sync/backfill.rb
+- lib/embed_sync/configuration.rb
+- lib/embed_sync/definition.rb
+- lib/embed_sync/embed_job.rb
+- lib/embed_sync/errors.rb
+- lib/embed_sync/log_subscriber.rb
+- lib/embed_sync/model.rb
+- lib/embed_sync/providers.rb
+- lib/embed_sync/providers/base.rb
+- lib/embed_sync/providers/fake.rb
+- lib/embed_sync/providers/ruby_llm.rb
+- lib/embed_sync/query.rb
+- lib/embed_sync/railtie.rb
+- lib/embed_sync/sync.rb
+- lib/embed_sync/tasks/embed_sync.rake
+- lib/embed_sync/version.rb
+- lib/generators/embed_sync/embed_sync_generator.rb
+- lib/generators/embed_sync/install_generator.rb
+- lib/generators/embed_sync/templates/initializer.rb.tt
+- lib/generators/embed_sync/templates/migration.rb.tt
+- sig/embed_sync.rbs
+homepage: https://github.com/Umair0092/embed_sync
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/Umair0092/embed_sync
+  source_code_uri: https://github.com/Umair0092/embed_sync
+  changelog_uri: https://github.com/Umair0092/embed_sync/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Keep vector embeddings in sync with your ActiveRecord models.
+test_files: []