ask-rag 0.2.2 → 0.4.0

data/lib/ask/rag/vector_store/pgvector.rb

@@ -15,7 +15,13 @@ module Ask
       #   #     t.jsonb :metadata
       #   #     t.vector :embedding, limit: 1536
       #   #   end
-      #   #   add_index :documents, :embedding, using: :ivfflat, opclass: :vector_cosine_ops
+      #   #   add_index :documents, :embedding, using: :hnsw, opclass: :vector_cosine_ops
+      #   #
+      #   #   # For hybrid search (recommended):
+      #   #   add_index :documents, "(to_tsvector('english', content))", using: :gin
+      #   #
+      #   #   # Makes `add` an upsert at the database level too:
+      #   #   add_index :documents, "(metadata ->> 'id')", unique: true
       #
       # @example Usage
       #   store = Ask::RAG::VectorStore::PGVector.new(
@@ -24,82 +30,151 @@ module Ask
       #   )
       #   store.add(chunks, model: "text-embedding-3-small")
       #   results = store.similarity_search("query", limit: 5)
+      #   results = store.hybrid_search("query", limit: 5)
+      #
+      # Document identity lives in the metadata column under +id+ (see
+      # DocumentId), not in the table's primary key: the table is the
+      # store's, the document id is the caller's. The effective primary key
+      # is the caller's, and `add` upserts on it.
       #
       class PGVector < VectorStore
-        # @param table_name [Symbol] the ActiveRecord table name
-        # @param content_column [Symbol] column storing text content (default: :content)
-        # @param metadata_column [Symbol] column storing JSON metadata (default: :metadata)
-        # @param embedding_column [Symbol] column storing the vector (default: :embedding)
+        include Embeddings
+        # How many dense results are pulled before MMR or fusion narrows
+        # them. Wider than any sane `limit` so MMR has candidates to choose
+        # between and RRF has ranks to merge.
+        CANDIDATE_LIMIT = 100
+
+        # @param table_name [Symbol, nil] the ActiveRecord table name
+        #   (default: configured table_name)
+        # @param content_column [Symbol, nil] column storing text content
+        #   (default: configured content_column)
+        # @param metadata_column [Symbol, nil] column storing JSON metadata
+        #   (default: configured metadata_column)
+        # @param embedding_column [Symbol, nil] column storing the vector
+        #   (default: configured embedding_column)
+        # @param text_search_config [String, nil] Postgres text search
+        #   configuration used by hybrid search (default: configured)
         # @param model_class [Class, nil] ActiveRecord model class (default: inferred from table_name)
-        def initialize(table_name:, content_column: :content, metadata_column: :metadata,
-                       embedding_column: :embedding, model_class: nil)
-          @table_name = table_name.to_s
-          @content_column = content_column.to_s
-          @metadata_column = metadata_column.to_s
-          @embedding_column = embedding_column.to_s
+        def initialize(table_name: nil, content_column: nil, metadata_column: nil,
+          embedding_column: nil, text_search_config: nil, model_class: nil)
+          # Nothing in this file needs the ORM or the pgvector client until
+          # an instance exists, so both load here rather than at require
+          # time: a plain-Ruby process that only uses InMemory should not
+          # boot ActiveRecord to require this gem.
+          begin
+            require "neighbor"
+          rescue LoadError
+            begin
+              require "pgvector"
+            rescue LoadError # rubocop:disable Lint/SuppressedException
+            end
+          end
+          begin
+            require "active_record"
+          rescue LoadError # rubocop:disable Lint/SuppressedException
+          end
+
+          unless defined?(ActiveRecord::Base)
+            raise EmbeddingError,
+              "Ask::RAG::VectorStore::PGVector needs ActiveRecord. " \
+              "Add `gem \"activerecord\"` (or `gem \"rails\"`) to your Gemfile, " \
+              "or use Ask::RAG::VectorStore::InMemory which needs no database."
+          end
+
+          config = Ask::RAG.configuration
+          @table_name = (table_name || config.table_name).to_s
+          @content_column = (content_column || config.content_column).to_s
+          @metadata_column = (metadata_column || config.metadata_column).to_s
+          @embedding_column = (embedding_column || config.embedding_column).to_s
+          @text_search_config = text_search_config || config.text_search_config
           @model_class = model_class || infer_model_class
           @embedding_model = nil
         end
 
-        def add(documents, model:, batch_size: 20)
-          ids = []
+        # Add documents, replacing any that share an id.
+        #
+        # Re-running an indexing job is the normal case, so this upserts:
+        # a document whose id already exists is updated in place rather than
+        # inserted a second time, and its embedding is not paid for twice
+        # beyond what the caller chose to re-embed.
+        #
+        # @param documents [Array<Ask::Document>] documents to add
+        # @param model [String, nil] embedding model name (default:
+        #   configured embedding_model)
+        # @param batch_size [Integer] documents per embed API call
+        # @return [Array<String>] the documents' ids
+        def add(documents, model: nil, batch_size: 20)
+          ids = documents.map { |document| DocumentId.for(document) }
+          model ||= default_embedding_model
           @embedding_model = model
 
-          documents.each_slice(batch_size) do |batch|
-            texts = batch.map(&:content)
-            vectors = embed_texts(texts, model)
-
-            batch.each_with_index do |doc, idx|
-              record = @model_class.create!(
-                @content_column => doc.content,
-                @metadata_column => doc.metadata,
-                @embedding_column => vectors[idx]
-              )
-              ids << record.id.to_s
+          documents.each_slice(batch_size).each_with_index.flat_map do |batch, batch_index|
+            offset = batch_index * batch_size
+            batch_ids = ids[offset, batch.length]
+            vectors = embed_texts(batch.map(&:content), model: model)
+            existing = existing_by_document_id(batch_ids)
+
+            batch.each_with_index.map do |document, index|
+              id = batch_ids[index]
+              write(document, id: id, vector: vectors[index], record: existing[id])
+              id
             end
           end
-
-          ids
         end
 
-        def similarity_search(query, limit: 10, filter: nil, mmr: false, diversity_bonus: 0.3)
+        def similarity_search(query, limit: 10, filter: nil, min_score: nil,
+          mmr: false, diversity_bonus: Retrieval::MaxMarginalRelevance::DEFAULT_DIVERSITY_BONUS)
           query_vector = embed_query(query)
-          similarity_search_by_vector(query_vector, limit: limit, filter: filter)
+          search_by_vector(query_vector, limit: limit, filter: filter, min_score: min_score,
+            mmr: mmr, diversity_bonus: diversity_bonus)
         end
 
-        def similarity_search_by_vector(vector, limit: 10, filter: nil)
-          vector_str = vector.is_a?(Array) ? "[#{vector.join(',')}]" : vector.to_s
-          column = "#{@table_name}.#{@embedding_column}"
-          model_class = @model_class
+        def similarity_search_by_vector(vector, limit: 10, filter: nil, min_score: nil,
+          mmr: false, diversity_bonus: Retrieval::MaxMarginalRelevance::DEFAULT_DIVERSITY_BONUS)
+          search_by_vector(vector, limit: limit, filter: filter, min_score: min_score,
+            mmr: mmr, diversity_bonus: diversity_bonus)
+        end
 
-          scope = model_class
-            .select("#{@table_name}.*, 1 - (#{column} <=> '#{vector_str}') AS score")
-            .where("#{column} IS NOT NULL")
+        # Dense + keyword retrieval, fused by Reciprocal Rank Fusion.
+        #
+        # The keyword half is Postgres full-text search over the content
+        # column, which is what catches exact terms an embedding blurs:
+        # identifiers, error codes, method names. A document both halves find
+        # outranks one that only a single half found.
+        #
+        # Add the GIN index shown in the class docs or the keyword half is a
+        # sequential scan; correctness does not depend on it, speed does.
+        #
+        # @param query [String] the query text
+        # @param limit [Integer] maximum results
+        # @param filter [Hash, nil] metadata filter
+        # @param min_score [Float, nil] drop vector results scoring below this
+        # @return [Array<Ask::Document>] documents with +:rrf_score+ in metadata
+        def hybrid_search(query, limit: 10, filter: nil, min_score: nil)
+          dense = similarity_search(query, limit: CANDIDATE_LIMIT, filter: filter, min_score: min_score)
+          # A query with no dense matches can still have exact-term matches,
+          # so the keyword half runs regardless rather than short-circuiting
+          # on an empty dense list.
+          lexical = keyword_search(query, limit: CANDIDATE_LIMIT, filter: filter)
 
-          if filter
-            filter.each do |key, value|
-              scope = scope.where("#{@metadata_column} @> ?", { key.to_s => value }.to_json)
-            end
-          end
+          Retrieval::ReciprocalRankFusion.fuse([dense, lexical], limit: limit)
+        end
 
-          records = scope
-            .order(Arel.sql("#{column} <=> '#{vector_str}'"))
-            .limit(limit)
-
-          records.map do |record|
-            Ask::Document.new(
-              content: record.send(@content_column),
-              metadata: (record.send(@metadata_column) || {}).merge(
-                score: record.score,
-                db_id: record.id
-              ),
-              id: record.id.to_s
-            )
-          end
+        # Remove every document whose metadata matches all given pairs.
+        # This is how stale chunks are cleared after a source is edited or
+        # removed — the complement to `add`'s stable ids.
+        #
+        # @param filter [Hash] metadata key/value pairs to match
+        # @return [Integer] number of documents removed
+        def delete_by(filter)
+          filter_scope(@model_class, filter).delete_all
         end
 
         def delete(ids)
-          @model_class.where(id: ids).delete_all
+          ids = Array(ids)
+          return 0 if ids.empty?
+
+          @model_class.where("#{@metadata_column} ->> 'id' IN (?)", ids).delete_all
         end
 
         def clear
@@ -112,49 +187,180 @@ module Ask
 
         private
 
+        # --- Writing ---
+
         def infer_model_class
           klass = Class.new(ActiveRecord::Base) # rubocop:disable Rails/ApplicationRecord
           klass.table_name = @table_name
           klass
         end
 
-        def embed_texts(texts, model)
-          provider = resolve_provider(model)
-          raw = provider.embed(texts, model: model)
-          raw = raw.output if raw.is_a?(Ask::Result)
-          Array(raw).map { |v| Array(v).map(&:to_f) }
+        # One query per batch rather than per document: the ids are known up
+        # front, so the upsert decision costs a single round trip.
+        #
+        # The store can only guarantee uniqueness for the rows it writes, so
+        # this takes the first row per id. A duplicate would mean the table
+        # was written outside the store; a unique index on
+        # `(metadata ->> 'id')` is the schema-level guarantee, documented in
+        # the class comment.
+        def existing_by_document_id(ids)
+          return {} if ids.empty?
+
+          @model_class
+            .where("#{@metadata_column} ->> 'id' IN (?)", ids)
+            .to_a
+            .each_with_object({}) do |record, result|
+              document_id = metadata_for(record)[:id]
+              result[document_id] ||= record
+            end
         end
 
-        def embed_query(query = "query")
-          model = @embedding_model || "text-embedding-3-small"
-          provider = resolve_provider(model)
-          raw = provider.embed(query, model: model)
-          raw = raw.output if raw.is_a?(Ask::Result)
-          Array(raw).flatten.map(&:to_f)
-        rescue StandardError => e
-          raise EmbeddingError, "Failed to embed query with model #{model}: #{e.message}"
+        def write(document, id:, vector:, record:)
+          record ||= @model_class.new
+          record[@content_column] = document.content
+          record[@metadata_column] = stringify_metadata(document.metadata).merge("id" => id)
+          record[@embedding_column] = vector
+          record.save!
+          record
         end
 
-        def resolve_provider(model)
-          info = Ask::ModelCatalog.find(model)
-          klass = Ask::Provider.resolve(info.provider)
-          config = build_config(klass)
-          klass.new(config)
-        rescue Ask::ModelNotFound, Ask::UnknownProvider
-          Ask::Provider.resolve(:openai).new(build_config(Ask::Provider.resolve(:openai)))
+        # jsonb stores string keys; writing symbol keys works but makes the
+        # stored row's shape depend on where it came from, which breaks the
+        # `@> ?` filters below.
+        def stringify_metadata(metadata)
+          metadata.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
         end
 
-        def build_config(klass)
-          config = Object.new
-          klass.configuration_requirements.each do |req|
-            val = ENV["#{req.to_s.upcase}"]
-            config.define_singleton_method(req) { val } if val
+        # jsonb stores string keys, so a round trip through the database
+        # would hand back `metadata["source"]` where the loaders wrote
+        # `metadata[:source]` — and `Query`, the README, and every caller
+        # written against the InMemory store read the symbol. Symbolizing on
+        # the way out keeps the two stores interchangeable, which is the
+        # point of having a base contract at all.
+        def metadata_for(record)
+          (record.send(@metadata_column) || {}).each_with_object({}) do |(key, value), result|
+            result[key.to_sym] = value
           end
-          klass.configuration_options.each do |opt|
-            val = ENV["#{opt.to_s.upcase}"]
-            config.define_singleton_method(opt) { val } if val
+        end
+
+        # --- Search ---
+
+        def search_by_vector(vector, limit:, filter: nil, min_score: nil, mmr: false,
+          diversity_bonus: Retrieval::MaxMarginalRelevance::DEFAULT_DIVERSITY_BONUS)
+          distance = distance_expression
+          # The vector comes from an embeddings API and is bound as a
+          # parameter here, never interpolated: `?::vector` binds the literal
+          # and the cast is what makes Postgres treat the text as a vector.
+          score = @model_class.sanitize_sql_array(["1 - (#{distance} <=> ?::vector)", vector_literal(vector)])
+          nearest = @model_class.sanitize_sql_array(["#{distance} <=> ?::vector", vector_literal(vector)])
+
+          scope = @model_class
+            .select("#{@table_name}.*, #{score} AS score")
+            .where("#{distance} IS NOT NULL")
+
+          # The threshold is applied in SQL, not after limiting: filtering in
+          # Ruby would return fewer than `limit` rows and hide the strong
+          # matches a wider fetch would have found.
+          scope = scope.where(@model_class.sanitize_sql_array(["#{score} >= ?", min_score])) if min_score
+
+          scope = filter_scope(scope, filter)
+          records = scope.order(Arel.sql(nearest)).limit(candidates_for(limit, mmr)).to_a
+
+          documents = records.map { |record| document_for(record, score: record.score) }
+          return documents unless mmr
+
+          select_diverse(records, documents, limit: limit, diversity_bonus: diversity_bonus)
+        end
+
+        # MMR needs the stored vectors to measure how alike candidates are,
+        # which is why the embedding column is selected before narrowing.
+        def select_diverse(records, documents, limit:, diversity_bonus:)
+          candidates = records.each_with_index.map do |record, index|
+            Retrieval::MaxMarginalRelevance::Candidate.new(
+              document: documents[index],
+              relevance: record.score.to_f,
+              vector: parse_vector(record.send(@embedding_column))
+            )
+          end
+
+          Retrieval::MaxMarginalRelevance.select(candidates, limit: limit, diversity_bonus: diversity_bonus)
+        end
+
+        def candidates_for(limit, mmr)
+          mmr ? [limit * 4, CANDIDATE_LIMIT].min : limit
+        end
+
+        def keyword_search(query, limit:, filter: nil)
+          return [] if query.to_s.strip.empty?
+
+          predicate = @model_class.sanitize_sql_array(
+            ["#{tsvector_expression} @@ websearch_to_tsquery(?, ?)", @text_search_config, query]
+          )
+          rank = @model_class.sanitize_sql_array(
+            ["ts_rank_cd(#{tsvector_expression}, websearch_to_tsquery(?, ?))",
+              @text_search_config, query]
+          )
+          order = @model_class.sanitize_sql_array(["#{rank} DESC, #{@table_name}.id ASC"])
+
+          scope = @model_class
+            .select("#{@table_name}.*, #{rank} AS lexical_score")
+            .where(predicate)
+
+          scope = filter_scope(scope, filter)
+
+          scope.order(Arel.sql(order)).limit(limit).map do |record|
+            document_for(record, lexical_score: record.lexical_score.to_f)
           end
-          config
+        end
+
+        # The text search configuration is a constructor argument rather than
+        # caller input, but it is interpolated into SQL, so it goes through
+        # the connection's quoting like anything else that reaches a query.
+        def tsvector_expression
+          config = @model_class.connection.quote(@text_search_config)
+          "to_tsvector(#{config}, #{@table_name}.#{@content_column})"
+        end
+
+        # The literal form of a vector for binding. Pgvector.encode is the
+        # ecosystem's encoder; the fallback keeps the store usable if a
+        # future pgvector drops it.
+        def vector_literal(vector)
+          values = vector.is_a?(Array) ? vector : Array(vector)
+          return Pgvector.encode(values) if defined?(Pgvector) && Pgvector.respond_to?(:encode)
+
+          "[#{values.map(&:to_f).join(",")}]"
+        end
+
+        def distance_expression
+          "#{@table_name}.#{@embedding_column}"
+        end
+
+        def filter_scope(scope, filter = nil)
+          return scope if filter.nil? || filter.empty?
+
+          scope.where("#{@metadata_column} @> ?", stringify_metadata(filter).to_json)
+        end
+
+        def document_for(record, score: nil, lexical_score: nil)
+          metadata = metadata_for(record)
+          extra = {}
+          extra[:score] = score.to_f unless score.nil?
+          extra[:lexical_score] = lexical_score unless lexical_score.nil?
+
+          Ask::Document.new(
+            content: record.send(@content_column),
+            metadata: metadata.merge(extra),
+            id: metadata[:id] || record.id.to_s
+          )
+        end
+
+        # Vectors arrive as arrays from pgvector's type decoder and as
+        # strings when the column is not registered on the model.
+        def parse_vector(value)
+          return nil if value.nil?
+          return value.to_a.map(&:to_f) if value.respond_to?(:to_a) && !value.is_a?(String)
+
+          value.to_s.delete("[]").split(",").map(&:to_f)
         end
       end
     end

data/lib/ask/rag/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module RAG
-    VERSION = "0.2.2"
+    VERSION = "0.4.0"
   end
 end

data/lib/ask/rag.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "rag/version"
+require_relative "rag/configuration"
+require_relative "rag/credentials"
 require_relative "rag/document"
+require_relative "rag/document_id"
 
 # Optional: Matrix for faster cosine similarity
 begin
@@ -35,15 +38,32 @@ require_relative "rag/text_splitter/base"
 require_relative "rag/text_splitter/recursive_character"
 require_relative "rag/text_splitter/markdown"
 
+# Retrieval primitives, shared by every store
+require_relative "rag/embeddings"
+require_relative "rag/retrieval/bm25"
+require_relative "rag/retrieval/reciprocal_rank_fusion"
+require_relative "rag/retrieval/max_marginal_relevance"
+
 # Vector stores
 require_relative "rag/vector_store/base"
 require_relative "rag/vector_store/in_memory"
 
-# Optional: PGVector
+# The class definition below is pure Ruby and loads anywhere; the pgvector
+# client gems and ActiveRecord itself are required lazily inside
+# PGVector#initialize, so InMemory-only apps never pay for the database
+# stack and the constructor can fail with a helpful message instead of a
+# bare NameError.
+require_relative "rag/vector_store/pgvector"
+
+require_relative "rag/query"
+
+# Rails integration ships in this gem: the Railtie loads only where
+# `rails/railtie` exists, so plain Ruby keeps working without railties.
+# ActiveSupport loads first — railtie.rb leans on delegate_missing_to and
+# config.ask_rag is an OrderedOptions.
 begin
-  require "pgvector"
-  require_relative "rag/vector_store/pgvector"
+  require "active_support"
+  require "rails/railtie"
+  require_relative "rag/railtie"
 rescue LoadError # rubocop:disable Lint/SuppressedException
 end
-
-require_relative "rag/query"

data/lib/generators/ask_rag/install/install_generator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/migration"
+
+module AskRag
+  module Generators
+    # Installs ask-rag into a Rails app: the pgvector migration and a
+    # commented initializer. The `kamal init` equivalent — run once, then
+    # edit the generated files.
+    #
+    #   bin/rails generate ask_rag:install
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path("templates", __dir__)
+
+      namespace "ask_rag:install"
+      desc "Creates the ask-rag embeddings migration and initializer"
+
+      def self.next_migration_number(_dir)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def create_embeddings_migration
+        migration_template "migration.rb.tt", "db/migrate/create_ask_rag_embeddings.rb"
+      end
+
+      def create_initializer
+        template "initializer.rb.tt", "config/initializers/ask_rag.rb"
+      end
+
+      def show_next_steps
+        say ""
+        say "ask-rag installed. Next steps:", :green
+        say "  1. Make sure the pgvector extension and neighbor gem are available:"
+        say '       gem "neighbor"   # registers the vector column type with ActiveRecord'
+        say "  2. Run the migration: bin/rails db:migrate"
+        say "  3. Put your provider key in credentials: bin/rails credentials:edit"
+        say "       ask:"
+        say "         openai_api_key: sk-..."
+        say "  4. Tune defaults in config/initializers/ask_rag.rb (all optional)"
+      end
+    end
+  end
+end

data/lib/generators/ask_rag/install/templates/initializer.rb.tt

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# ask-rag configuration. Every setting below overrides the gem default of
+# the same name; anything commented out keeps that default.
+#
+# Provider API keys resolve without any code here: Rails credentials first
+# (ask.openai_api_key), then the OPENAI_API_KEY environment variable.
+
+Ask::RAG.configure do |config|
+  # Embedding model used by stores when a call omits `model:`.
+  # config.embedding_model = "text-embedding-3-small"
+
+  # Answer model used by Ask::RAG::Query when a call omits `model:`.
+  # config.chat_model = "gpt-4o"
+
+  # PGVector store defaults — used when PGVector.new omits them.
+  # config.table_name = :ask_rag_embeddings
+  # config.content_column = :content
+  # config.metadata_column = :metadata
+  # config.embedding_column = :embedding
+  # config.text_search_config = "english"
+
+  # Vector length for the migration `t.vector limit:` above.
+  # config.embedding_dimensions = 1536
+end

data/lib/generators/ask_rag/install/templates/migration.rb.tt

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateAskRagEmbeddings < ActiveRecord::Migration[7.0]
+  def change
+    enable_extension "vector"
+
+    create_table :ask_rag_embeddings do |t|
+      t.text :content, null: false
+      t.jsonb :metadata, null: false, default: {}
+      t.vector :embedding, limit: 1536
+    end
+
+    add_index :ask_rag_embeddings, :embedding, using: :hnsw, opclass: :vector_cosine_ops
+    add_index :ask_rag_embeddings, "(to_tsvector('english', content))",
+      using: :gin, name: "index_ask_rag_embeddings_on_content_tsvector"
+    add_index :ask_rag_embeddings, "(metadata ->> 'id')",
+      unique: true, name: "index_ask_rag_embeddings_on_metadata_id"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-rag
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.3
 - !ruby/object:Gem::Dependency
   name: csv
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +93,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
 description: Document loaders, text splitters, vector stores, and retrieval queries
   for building RAG applications with ask-rb.
 email:
@@ -106,7 +120,11 @@ files:
 - README.md
 - lib/ask-rag.rb
 - lib/ask/rag.rb
+- lib/ask/rag/configuration.rb
+- lib/ask/rag/credentials.rb
 - lib/ask/rag/document.rb
+- lib/ask/rag/document_id.rb
+- lib/ask/rag/embeddings.rb
 - lib/ask/rag/loader/base.rb
 - lib/ask/rag/loader/csv.rb
 - lib/ask/rag/loader/directory.rb
@@ -116,6 +134,10 @@ files:
 - lib/ask/rag/loader/pdf.rb
 - lib/ask/rag/loader/text.rb
 - lib/ask/rag/query.rb
+- lib/ask/rag/railtie.rb
+- lib/ask/rag/retrieval/bm25.rb
+- lib/ask/rag/retrieval/max_marginal_relevance.rb
+- lib/ask/rag/retrieval/reciprocal_rank_fusion.rb
 - lib/ask/rag/text_splitter/base.rb
 - lib/ask/rag/text_splitter/markdown.rb
 - lib/ask/rag/text_splitter/recursive_character.rb
@@ -123,6 +145,9 @@ files:
 - lib/ask/rag/vector_store/in_memory.rb
 - lib/ask/rag/vector_store/pgvector.rb
 - lib/ask/rag/version.rb
+- lib/generators/ask_rag/install/install_generator.rb
+- lib/generators/ask_rag/install/templates/initializer.rb.tt
+- lib/generators/ask_rag/install/templates/migration.rb.tt
 homepage: https://github.com/ask-rb/ask-rag
 licenses:
 - MIT
@@ -144,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.18
 specification_version: 4
 summary: RAG pipeline for the ask-rb ecosystem
 test_files: []