Searchkick Documentation

Data in associations is not automatically synced when the association is updated. To ensure changes in an associated model trigger a reindex of the parent, add an after_commit callback to the child model.

class Image < ApplicationRecord
  belongs_to :product

  after_commit :reindex_product

  def reindex_product
    product.reindex
  end
end

Searchkick supports STI by setting inheritance: true on the parent model. This allows you to search across all types or filter by specific subclasses using the .type() method.

Note: This relies on an automatic type field. Avoid defining your own type field in search_data to prevent conflicts.

class Animal < ApplicationRecord
  searchkick inheritance: true
end

class Dog < Animal
end

# Searching
Animal.search("*")                # all animals
Dog.search("*")                   # just dogs
Animal.search("*").type(Cat, Dog) # just cats and dogs

By default, all records are indexed. To restrict indexing to specific records (e.g., only active records), implement the should_index? method. This is also useful for excluding records that are filtered out by a default_scope.

class Product < ApplicationRecord
  # Only index active records
  def should_index?
    active
  end
end

# If you have a default_scope that filters records, use should_index? to exclude them:
class Product < ApplicationRecord
  default_scope { where(deleted_at: nil) }

  def should_index?
    deleted_at.nil?
  end
end

Semantic search uses kNN to find results based on vector embeddings. Hybrid search combines keyword search and semantic search in parallel.

• Hybrid Search (RRF): Use Searchkick::Reranking.rrf(keyword_search, semantic_search) to combine results using Reciprocal Rank Fusion.
• Hybrid Search (Reranking Model): Manually combine results and pass them through a reranking model (e.g., using Informers).

To improve performance, push record IDs to a queue for bulk reindexing.

1. Set up Redis in an initializer (using connection_pool is recommended): Searchkick.redis = ConnectionPool.new { Redis.new }.
2. Enable queuing in your model: searchkick callbacks: :queue.
3. Run the background job: Searchkick::ProcessQueueJob.perform_later(class_name: "Product").
4. Check queue length: Product.search_index.reindex_queue.length.

# Initializer
Searchkick.redis = ConnectionPool.new { Redis.new }

# Model
class Product < ApplicationRecord
  searchkick callbacks: :queue
end

# Background Job
Searchkick::ProcessQueueJob.perform_later(class_name: "Product")

Use the following methods to debug how Searchkick processes queries:

• .debug: Prints query information to stdout.
• .explain.response: Shows how the search server scores queries.
• .search_index.tokens(text, analyzer: "..."): Shows how a specific string is tokenized by a specific analyzer (e.g., searchkick_index, searchkick_search, searchkick_word_start_index).

# Debugging
Product.search("soap").debug
Product.search("soap").explain.response

# Tokenization inspection
Product.search_index.tokens("San Diego", analyzer: "searchkick_word_start_index")

Searchkick 6 introduces a new query builder API and improved conversion performance. You can use the new method-based syntax or continue using the old API. To upgrade conversions without downtime, follow the dual-field pattern.

# New Query Builder API
Product.search("apples").where(in_stock: true).limit(10).offset(50)

# Zero-downtime conversion upgrade pattern
class Product < ApplicationRecord
  searchkick conversions: [:conversions], conversions_v2: [:conversions_v2]

  def search_data
    conversions = searches.group(:query).distinct.count(:user_id)
    {
      conversions: conversions,
      conversions_v2: conversions
    }
  end
end

# After reindexing, remove the old 'conversions' key

Use the search_data method in your model to define which attributes and associations should be indexed. After modifying this method, you must call ModelName.reindex to update the index.

To optimize the import process and eager load associations, define a search_import scope.

class Product < ApplicationRecord
  belongs_to :department

  def search_data
    {
      name: name,
      department_name: department.name,
      on_sale: sale_price.present?
    }
  end
end

# To eager load associations during reindexing:
class Product < ApplicationRecord
  scope :search_import, -> { includes(:department) }
end

Searchkick integrates with kaminari and will_paginate. In your controller, use .page() and .per_page() to handle pagination.

# Controller
@products = Product.search("milk").page(params[:page]).per_page(20)

In your views:

<%# Using kaminari %>
<%= paginate @products %>

<%# Using will_paginate %>
<%= will_paginate @products %>

To enable search functionality on an Active Record or Mongoid model, add the searchkick method to the class definition.

class Product < ApplicationRecord
  searchkick
end