active_record-vector 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 24566066c866ee7bcbbc82f66d629de57cc0a1dc22ff2f10a807aa422129513a
+  data.tar.gz: 8577baf91f536e46467ae6d1552c1500515a772fd8d437e70408caa4e73e2407
+SHA512:
+  metadata.gz: c20374c7843a1c6a6b5443a808adfcb6e51184731af5d88588b091d4f75a7b4175fce58ca48881c7e5dc63cc614d12048dd7ffc463d92cbe8d8024d70d0df6c5
+  data.tar.gz: 2fc8a4903f0e88df02ec050158a2a10e358b6e5d8b48c6802829b2ec559a7db427ce7e6bc488a291054c6829d3a42d33b3148ea4ec8e5e34552c2576a3d3a614

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2026-08-03
+
+### Added
+- Initial release of `active_record-vector`
+- `has_vector` macro for ActiveRecord models
+- Multi-provider AI embedding support: OpenAI, Ollama (100% free local AI), Cohere, Custom lambdas
+- Vector distance metrics: Cosine similarity, Euclidean distance (L2), Inner product
+- `semantic_search` and `nearest_to` ActiveRecord scopes
+- `ActiveRecordVector::Chunker` for splitting long document text in RAG pipelines
+- Migration DSL extensions (`add_vector_column`, `add_vector_index`)
+- Support for PostgreSQL `pgvector` index operations (`HNSW`, `IVFFlat`)

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aditya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,142 @@
+<p align="center">
+  <h1 align="center">🧠 active_record-vector</h1>
+  <p align="center">
+    <strong>Native AI vector embeddings, semantic search & RAG for Rails ActiveRecord</strong>
+  </p>
+  <p align="center">
+    <a href="https://rubygems.org/gems/active_record-vector"><img src="https://img.shields.io/gem/v/active_record-vector?color=%23e9573f" alt="Gem Version"></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
+    <a href="https://rubygems.org/gems/active_record-vector"><img src="https://img.shields.io/gem/dt/active_record-vector?color=green" alt="Downloads"></a>
+  </p>
+</p>
+
+---
+
+**`active_record-vector`** gives any Rails ActiveRecord model native AI vector embedding generation, semantic similarity search, and RAG (Retrieval-Augmented Generation) document chunking capabilities in 2 lines of code.
+
+Works out-of-the-box with **OpenAI**, **Ollama** (100% free local AI), **Cohere**, **pgvector** (PostgreSQL), and SQLite/MySQL.
+
+---
+
+## ✨ Features
+
+- 🤖 **`has_vector` Macro**: Automatically generates & updates AI vector embeddings on model save callbacks.
+- 🔍 **Native ActiveRecord Scopes**: Chain `.semantic_search("query")` and `.nearest_to(vector)` directly with standard Rails queries (`where`, `limit`, `order`).
+- 🆓 **Free Local AI via Ollama**: Generate embeddings 100% offline, locally, and free using `nomic-embed-text` or `all-minilm`.
+- ⚡ **Multi-Provider Support**: OpenAI (`text-embedding-3-small`), Ollama, Cohere, or custom Procs/Lambdas.
+- 📑 **RAG Text Chunker**: Built-in document text splitting utility (`ActiveRecordVector::Chunker`) with token-aware overlap.
+- 🗄️ **PostgreSQL `pgvector` Integration**: Migration DSL extensions (`add_vector_column`, `add_vector_index`) supporting `HNSW` and `IVFFlat` indexes with fallback Ruby distance algorithms for SQLite/MySQL.
+
+---
+
+## 📦 Installation
+
+Add to your Rails application's `Gemfile`:
+
+```ruby
+gem "active_record-vector"
+```
+
+And execute:
+```bash
+bundle install
+```
+
+---
+
+## 🚀 Quick Start
+
+### 1. Define Model Vector Embeddings
+
+Add `has_vector` to your ActiveRecord model:
+
+```ruby
+class Article < ApplicationRecord
+  has_vector :embedding,
+             provider: :openai,                 # :openai, :ollama, :cohere, or custom proc
+             model: "text-embedding-3-small",
+             from: [:title, :body],              # concatenated automatically
+             auto_generate: true                # before_save callback
+end
+```
+
+### 2. Semantic Similarity Search
+
+Perform vector similarity searches using standard Rails scopes:
+
+```ruby
+# Semantic search by query text
+Article.semantic_search("Ruby on Rails 8 performance", limit: 5)
+
+# Chain with standard ActiveRecord queries
+Article.where(published: true)
+       .semantic_search("AI integration", limit: 10)
+```
+
+---
+
+## 🦙 Free Local AI Embeddings with Ollama
+
+Generate embeddings 100% offline, privately, and for free using [Ollama](https://ollama.com/):
+
+```ruby
+class Article < ApplicationRecord
+  has_vector :embedding,
+             provider: :ollama,
+             model: "nomic-embed-text",  # or "all-minilm"
+             host: "http://localhost:11434",
+             from: :body
+end
+```
+
+---
+
+## 📑 RAG Document Text Chunker
+
+Split long documents into overlapping chunks for embedding generation in RAG pipelines:
+
+```ruby
+# Split long document text
+chunks = ActiveRecordVector::Chunker.split(long_text, chunk_size: 1000, chunk_overlap: 200)
+
+chunks.each do |chunk_text|
+  article.chunks.create!(content: chunk_text) # auto-generates vector embedding
+end
+```
+
+---
+
+## 🛠️ Rails Migration Helpers
+
+```ruby
+class AddEmbeddingToArticles < ActiveRecord::Migration[7.2]
+  def change
+    # Adds pgvector column (or text column fallback on SQLite)
+    add_vector_column :articles, :embedding, dimensions: 1536
+
+    # Adds HNSW vector index for high-speed similarity queries
+    add_vector_index :articles, :embedding, type: :hnsw, distance: :cosine
+  end
+end
+```
+
+---
+
+## 🛠️ Local Development & Testing
+
+```bash
+git clone https://github.com/aditya-8108/active_record-vector.git
+cd active_record-vector
+
+bundle config set --local path 'vendor/bundle'
+bundle install
+
+# Run test suite
+bundle exec rspec
+```
+
+---
+
+## 📄 License
+
+Distributed under the [MIT License](LICENSE).

data/lib/active_record_vector/chunker.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ActiveRecordVector
+  # Document text chunking utility for RAG (Retrieval-Augmented Generation) pipelines.
+  # Splits long texts into overlapping chunks for embedding generation.
+  class Chunker
+    attr_reader :chunk_size, :chunk_overlap, :separators
+
+    DEFAULT_SEPARATORS = ["\n\n", "\n", ". ", " ", ""].freeze
+
+    def initialize(chunk_size: 1000, chunk_overlap: 200, separators: DEFAULT_SEPARATORS)
+      @chunk_size = chunk_size
+      @chunk_overlap = chunk_overlap
+      @separators = separators
+    end
+
+    # Convenience class method
+    def self.split(text, chunk_size: 1000, chunk_overlap: 200)
+      new(chunk_size: chunk_size, chunk_overlap: chunk_overlap).split(text)
+    end
+
+    # Split text into array of chunk strings
+    def split(text)
+      return [] if text.nil? || text.strip.empty?
+      return [text.strip] if text.length <= @chunk_size
+
+      splits = split_text(text, @separators)
+      merge_splits(splits)
+    end
+
+    private
+
+    def split_text(text, separators)
+      separator = separators.find { |s| s.empty? || text.include?(s) } || ""
+      return text.chars if separator.empty?
+
+      parts = text.split(separator)
+      result = []
+      parts.each_with_index do |part, idx|
+        piece = idx.zero? ? part : "#{separator}#{part}"
+        if piece.length > @chunk_size && separators.length > 1
+          next_separators = separators[(separators.index(separator) + 1)..]
+          result.concat(split_text(piece, next_separators))
+        else
+          result << piece
+        end
+      end
+      result
+    end
+
+    def merge_splits(splits)
+      chunks = []
+      current_chunk = []
+      current_length = 0
+
+      splits.each do |split|
+        split_len = split.length
+
+        if current_length + split_len > @chunk_size && current_chunk.any?
+          chunk_str = current_chunk.join.strip
+          chunks << chunk_str unless chunk_str.empty?
+
+          # Keep overlap
+          while current_length > @chunk_overlap && current_chunk.any?
+            removed = current_chunk.shift
+            current_length -= removed.length
+          end
+        end
+
+        current_chunk << split
+        current_length += split_len
+      end
+
+      if current_chunk.any?
+        final_str = current_chunk.join.strip
+        chunks << final_str unless final_str.empty?
+      end
+
+      chunks
+    end
+  end
+end

data/lib/active_record_vector/distance.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveRecordVector
+  # Vector distance and similarity calculations.
+  module Distance
+    class << self
+      # Cosine similarity between two float arrays (returns value between -1.0 and 1.0)
+      def cosine_similarity(vec_a, vec_b)
+        return 0.0 if vec_a.nil? || vec_b.nil? || vec_a.empty? || vec_b.empty?
+        return 0.0 unless vec_a.length == vec_b.length
+
+        dot = 0.0
+        norm_a = 0.0
+        norm_b = 0.0
+
+        vec_a.each_with_index do |val, idx|
+          b_val = vec_b[idx]
+          dot += val * b_val
+          norm_a += val * val
+          norm_b += b_val * b_val
+        end
+
+        denom = Math.sqrt(norm_a) * Math.sqrt(norm_b)
+        return 0.0 if denom.zero?
+
+        dot / denom
+      end
+
+      # Euclidean distance (L2 norm) between two float arrays
+      def euclidean_distance(vec_a, vec_b)
+        return Float::INFINITY if vec_a.nil? || vec_b.nil? || vec_a.empty? || vec_b.empty?
+        return Float::INFINITY unless vec_a.length == vec_b.length
+
+        sum = 0.0
+        vec_a.each_with_index do |val, idx|
+          diff = val - vec_b[idx]
+          sum += diff * diff
+        end
+
+        Math.sqrt(sum)
+      end
+
+      # Dot product (inner product) between two float arrays
+      def inner_product(vec_a, vec_b)
+        return 0.0 if vec_a.nil? || vec_b.nil? || vec_a.empty? || vec_b.empty?
+        return 0.0 unless vec_a.length == vec_b.length
+
+        sum = 0.0
+        vec_a.each_with_index do |val, idx|
+          sum += val * vec_b[idx]
+        end
+        sum
+      end
+    end
+  end
+end

data/lib/active_record_vector/migration_helper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveRecordVector
+  # Helper module providing migration DSL extensions for adding vector columns and indexes.
+  module MigrationHelper
+    # Add vector column to a table (supports PostgreSQL pgvector and JSON fallback)
+    def add_vector_column(table_name, column_name, dimensions: 1536, **options)
+      if postgresql_adapter?
+        execute "CREATE EXTENSION IF NOT EXISTS vector;"
+        execute "ALTER TABLE #{table_name} ADD COLUMN #{column_name} vector(#{dimensions});"
+      else
+        add_column table_name, column_name, :text, **options
+      end
+    end
+
+    # Add HNSW or IVFFlat vector index to a table
+    def add_vector_index(table_name, column_name, type: :hnsw, distance: :cosine)
+      return unless postgresql_adapter?
+
+      ops_class = case distance.to_sym
+                  when :cosine then "vector_cosine_ops"
+                  when :inner_product, :dot then "vector_ip_ops"
+                  else "vector_l2_ops"
+                  end
+
+      index_type = type.to_s.upcase
+      index_name = "index_#{table_name}_on_#{column_name}_#{type}"
+
+      execute "CREATE INDEX IF NOT EXISTS #{index_name} ON #{table_name} USING #{index_type} (#{column_name} #{ops_class});"
+    end
+
+    private
+
+    def postgresql_adapter?
+      respond_to?(:adapter_name) && adapter_name.to_s.match?(/postgres/i)
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/active_record_vector/model.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module ActiveRecordVector
+  # Module included in ActiveRecord models to provide vector capabilities.
+  module Model
+    extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Macro to enable vector capabilities on a model attribute
+      #
+      # Example:
+      #   has_vector :embedding,
+      #              provider: :openai,
+      #              model: "text-embedding-3-small",
+      #              from: [:title, :body],
+      #              auto_generate: true
+      def has_vector(attribute = :embedding, options = {})
+        @vector_configs ||= {}
+        @vector_configs[attribute.to_sym] = {
+          provider: options[:provider] || :openai,
+          model: options[:model],
+          from: Array(options[:from] || :content),
+          auto_generate: options.fetch(:auto_generate, true),
+          provider_options: options
+        }
+
+        # Setup auto-generation callback if supported
+        if options.fetch(:auto_generate, true) && respond_to?(:before_save)
+          before_save do
+            generate_vector_embeddings(attribute.to_sym)
+          end
+        end
+
+        # Define semantic search scopes if supported
+        return unless respond_to?(:scope)
+
+        scope :semantic_search, lambda { |query, target_attribute: attribute, limit: 10, distance: :cosine|
+          nearest_to(query, attribute: target_attribute, distance: distance).limit(limit)
+        }
+
+        scope :nearest_to, lambda { |query_or_vector, target_attribute: attribute, distance: :cosine|
+          cfg = @vector_configs[target_attribute.to_sym] || {}
+          query_vector = if query_or_vector.is_a?(Array)
+                           query_or_vector
+                         else
+                           ActiveRecordVector.provider_for(cfg[:provider], cfg[:provider_options]).embed(query_or_vector.to_s)
+                         end
+
+          if pgvector_supported?
+            pgvector_nearest(query_vector, target_attribute, distance)
+          else
+            ruby_vector_nearest(query_vector, target_attribute, distance)
+          end
+        }
+      end
+
+      def vector_configs
+        @vector_configs ||= {}
+      end
+
+      private
+
+      def pgvector_supported?
+        respond_to?(:connection) && connection.class.name.include?("PostgreSQL")
+      rescue StandardError
+        false
+      end
+
+      def pgvector_nearest(vector, attribute, distance)
+        vector_str = "[#{vector.join(',')}]"
+        col_name = connection.quote_column_name(attribute)
+
+        op = case distance.to_sym
+             when :cosine then "<=>"
+             when :inner_product, :dot then "<#>"
+             else "<->" # Euclidean L2
+             end
+
+        order("#{col_name} #{op} '#{vector_str}'")
+      end
+
+      def ruby_vector_nearest(vector, attribute, distance)
+        # Fetch records and sort in memory using ActiveRecordVector::Distance
+        records = all.to_a
+        sorted = records.sort_by do |record|
+          rec_vec = record.public_send(attribute)
+          next Float::INFINITY if rec_vec.nil?
+
+          # Parse vector if stored as JSON string
+          rec_vec = JSON.parse(rec_vec) if rec_vec.is_a?(String)
+
+          case distance.to_sym
+          when :cosine
+            -Distance.cosine_similarity(vector, rec_vec) # descending similarity
+          when :inner_product, :dot
+            -Distance.inner_product(vector, rec_vec)
+          else
+            Distance.euclidean_distance(vector, rec_vec) # ascending distance
+          end
+        end
+
+        # Return a scope-like relation using primary keys
+        ids = sorted.map(&:id)
+        return where(id: nil) if ids.empty?
+
+        begin
+          where(id: ids).in_order_of(:id, ids)
+        rescue StandardError
+          where(id: ids)
+        end
+      end
+    end
+
+    # Instance Methods
+    def generate_vector_embeddings(attribute = :embedding)
+      cfg = self.class.vector_configs[attribute.to_sym]
+      return unless cfg
+
+      source_text = vector_source_text(attribute)
+      return if source_text.strip.empty?
+
+      provider = ActiveRecordVector.provider_for(cfg[:provider], cfg[:provider_options])
+      vector = provider.embed(source_text)
+
+      public_send("#{attribute}=", vector)
+    end
+
+    def vector_source_text(attribute = :embedding)
+      cfg = self.class.vector_configs[attribute.to_sym]
+      return "" unless cfg
+
+      from_attrs = cfg[:from]
+      parts = from_attrs.filter_map do |attr|
+        val = respond_to?(attr) ? public_send(attr) : nil
+        val.to_s.strip unless val.nil? || val.to_s.strip.empty?
+      end
+
+      parts.join("\n\n")
+    end
+  end
+end

data/lib/active_record_vector/providers/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveRecordVector
+  module Providers
+    # Abstract base class for embedding providers.
+    class Base
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Generate embedding vector array for input text string
+      def embed(_text)
+        raise NotImplementedError, "#{self.class.name}#embed must be implemented"
+      end
+
+      # Generate batch embedding vector arrays for array of text strings
+      def embed_batch(texts)
+        texts.map { |text| embed(text) }
+      end
+    end
+  end
+end

data/lib/active_record_vector/providers/cohere.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module ActiveRecordVector
+  module Providers
+    # Cohere Embedding Provider
+    class Cohere < Base
+      DEFAULT_MODEL = "embed-english-v3.0"
+      API_ENDPOINT = "https://api.cohere.com/v1/embed"
+
+      def embed(text)
+        api_key = options[:api_key] || ENV.fetch("COHERE_API_KEY", nil)
+        raise Error, "Cohere API key missing. Set ENV['COHERE_API_KEY'] or pass api_key: '...'" unless api_key
+
+        uri = URI.parse(options[:endpoint] || API_ENDPOINT)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+
+        payload = {
+          texts: [text],
+          model: options[:model] || DEFAULT_MODEL,
+          input_type: options[:input_type] || "search_document"
+        }
+
+        request = Net::HTTP::Post.new(uri.request_uri, {
+                                        "Content-Type" => "application/json",
+                                        "Authorization" => "Bearer #{api_key}"
+                                      })
+        request.body = payload.to_json
+
+        response = http.request(request)
+        raise Error, "Cohere API Error (#{response.code}): #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body)
+        data.dig("embeddings", 0) || []
+      end
+    end
+  end
+end

data/lib/active_record_vector/providers/custom.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveRecordVector
+  module Providers
+    # Custom provider allowing any Proc, Lambda, or custom object responding to #call or #embed
+    class Custom < Base
+      def embed(text)
+        callable = options[:with] || options[:proc]
+        raise Error, "Custom provider requires options[:with] to be a Proc or object responding to #call" unless callable
+
+        if callable.respond_to?(:call)
+          callable.call(text)
+        elsif callable.respond_to?(:embed)
+          callable.embed(text)
+        else
+          raise Error, "Custom provider options[:with] must respond to #call or #embed"
+        end
+      end
+    end
+  end
+end

data/lib/active_record_vector/providers/ollama.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module ActiveRecordVector
+  module Providers
+    # Ollama Embedding Provider for 100% free, local, private offline AI embeddings
+    class Ollama < Base
+      DEFAULT_MODEL = "nomic-embed-text"
+      DEFAULT_HOST = "http://localhost:11434"
+
+      def embed(text)
+        base_host = options[:host] || ENV["OLLAMA_HOST"] || DEFAULT_HOST
+        uri = URI.parse("#{base_host.chomp('/')}/api/embeddings")
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = options[:timeout] || 15
+        http.read_timeout = options[:timeout] || 15
+
+        payload = {
+          model: options[:model] || DEFAULT_MODEL,
+          prompt: text
+        }
+
+        request = Net::HTTP::Post.new(uri.request_uri, {
+                                        "Content-Type" => "application/json"
+                                      })
+        request.body = payload.to_json
+
+        response = http.request(request)
+        raise Error, "Ollama API Error (#{response.code}): #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body)
+        data["embedding"] || []
+      end
+    end
+  end
+end

data/lib/active_record_vector/providers/openai.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module ActiveRecordVector
+  module Providers
+    # OpenAI Embedding Provider (supports text-embedding-3-small, text-embedding-3-large, text-embedding-ada-002)
+    class Openai < Base
+      DEFAULT_MODEL = "text-embedding-3-small"
+      API_ENDPOINT = "https://api.openai.com/v1/embeddings"
+
+      def embed(text)
+        api_key = options[:api_key] || ENV.fetch("OPENAI_API_KEY", nil)
+        raise Error, "OpenAI API key missing. Set ENV['OPENAI_API_KEY'] or pass api_key: '...' to has_vector" unless api_key
+
+        uri = URI.parse(options[:endpoint] || API_ENDPOINT)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = options[:timeout] || 10
+        http.read_timeout = options[:timeout] || 10
+
+        payload = {
+          input: text,
+          model: options[:model] || DEFAULT_MODEL
+        }
+        payload[:dimensions] = options[:dimensions] if options[:dimensions]
+
+        request = Net::HTTP::Post.new(uri.request_uri, {
+                                        "Content-Type" => "application/json",
+                                        "Authorization" => "Bearer #{api_key}"
+                                      })
+        request.body = payload.to_json
+
+        response = http.request(request)
+        raise Error, "OpenAI API Error (#{response.code}): #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body)
+        data.dig("data", 0, "embedding") || []
+      end
+    end
+  end
+end

data/lib/active_record_vector/version.rb

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

data/lib/active_record_vector.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "active_record_vector/version"
+require_relative "active_record_vector/distance"
+require_relative "active_record_vector/chunker"
+require_relative "active_record_vector/providers/base"
+require_relative "active_record_vector/providers/openai"
+require_relative "active_record_vector/providers/ollama"
+require_relative "active_record_vector/providers/cohere"
+require_relative "active_record_vector/providers/custom"
+require_relative "active_record_vector/model"
+require_relative "active_record_vector/migration_helper"
+
+module ActiveRecordVector
+  class Error < StandardError; end
+
+  class << self
+    # Provider registry lookup
+    def provider_for(provider_name, options = {})
+      case provider_name.to_sym
+      when :openai
+        Providers::Openai.new(options)
+      when :ollama
+        Providers::Ollama.new(options)
+      when :cohere
+        Providers::Cohere.new(options)
+      when :custom
+        Providers::Custom.new(options)
+      else
+        if provider_name.is_a?(Class) && provider_name < Providers::Base
+          provider_name.new(options)
+        elsif provider_name.respond_to?(:call) || provider_name.respond_to?(:embed)
+          Providers::Custom.new(options.merge(with: provider_name))
+        else
+          raise Error, "Unknown embedding provider: #{provider_name.inspect}"
+        end
+      end
+    end
+  end
+end
+
+# Auto-hook into ActiveRecord if defined
+ActiveRecord::Base.include(ActiveRecordVector::Model) if defined?(ActiveRecord::Base)

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: active_record-vector
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aditya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: An elegant, lightweight Ruby gem bringing native AI vector embeddings,
+  semantic similarity search, and RAG document chunking to Rails ActiveRecord models.
+  Supports OpenAI, Ollama (free local AI), Cohere, and pgvector.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/active_record_vector.rb
+- lib/active_record_vector/chunker.rb
+- lib/active_record_vector/distance.rb
+- lib/active_record_vector/migration_helper.rb
+- lib/active_record_vector/model.rb
+- lib/active_record_vector/providers/base.rb
+- lib/active_record_vector/providers/cohere.rb
+- lib/active_record_vector/providers/custom.rb
+- lib/active_record_vector/providers/ollama.rb
+- lib/active_record_vector/providers/openai.rb
+- lib/active_record_vector/version.rb
+homepage: https://github.com/aditya-8108/active_record-vector
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aditya-8108/active_record-vector
+  source_code_uri: https://github.com/aditya-8108/active_record-vector
+  changelog_uri: https://github.com/aditya-8108/active_record-vector/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Native vector embeddings, semantic search & RAG for Rails ActiveRecord
+test_files: []