documentrix 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7987ac709860e4747aec91c9d99b766e1b959b40142ebb17a3516aa80a0f6b85
+  data.tar.gz: a9ea8a8f360bef62ad687d1ecbcf04e6a978dc7450a76f26d97c6f04ee1bdf62
+SHA512:
+  metadata.gz: ba03da2c50fffb014489ee3281765e1ad0712da263dae1a6f45d5f449aba345113f28c093c7d2df14986ad283aee6cbd88c8545c6a7dceaacadff405ad27f457
+  data.tar.gz: 3a10470a23349509a575e79ab1ca18b0969827ef7f720f745537de83924348109cb3fcbd4b7a4a9703daebb471489948ec26ba704362838ad41fa546bb0040f2

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,5 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,71 @@
+# Documentrix - Ruby library for embedding vector database
+
+## Description
+
+The Ruby library, Documentrix, is designed to provide a way to build and
+query vector databases for applications in natural language processing
+(NLP) and large language models (LLMs). It allows users to store and
+retrieve dense vector embeddings for text strings.
+
+## Installation (gem & bundler)
+
+To install Documentrix, you can use the following methods:
+
+### Using the gem command
+
+Type `gem install documentrix` in your terminal.
+
+### Using Bundler
+
+Add the line `gem 'documentrix'` to your Gemfile and run `bundle install` in
+your terminal.
+
+## Usage
+
+In your own software the library can be used as shown in this example:
+
+```ruby
+# Require necessary libraries: ollama-ruby and documentrix
+require 'ollama'
+require 'documentrix'
+
+# Initialize an Ollama client instance, pointing to a local server
+ollama = Ollama::Client.new(base_url: 'http://localhost:11434')
+
+# Create a new Documentrix documents instance
+documents = Documentrix::Documents.new(
+  ollama: ollama,
+  model: 'mxbai-embed-large',
+  collection: 'my-collection',
+  cache: Documentrix::Documents::SQLiteCache
+)
+
+# Split sample text into individual chunks using recursive character splitting
+splitter = Documentrix::Documents::Splitters::RecursiveCharacter.new
+text     = "hay hay hay…" # Sample text data
+chunks   = splitter.split(text)
+documents.add(chunks)
+
+# Search the document collection for matching records
+query   = "What needles can you find in a haystack" # Search query
+records = documents.find_where(
+  query,
+  prompt: 'Represent this sentence for searching relevant passages: %s',
+  text_size: 4096,
+  text_count: 10
+)
+```
+
+## Download
+
+The homepage of this library is located at
+
+* https://github.com/flori/documentrix
+
+## Author
+
+<b>Documentrix</b> was written by [Florian Frank](mailto:flori@ping.de)
+
+## License
+
+This software is licensed under the <i>MIT</i> license.

data/Rakefile

@@ -0,0 +1,48 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+require 'gem_hadar'
+
+GemHadar do
+  name        'documentrix'
+  module_type :module
+  author      'Florian Frank'
+  email       'flori@ping.de'
+  homepage    "https://github.com/flori/#{name}"
+  summary     '"Ruby library for embedding vector database'
+  description <<~EOT
+    The Ruby library, Documentrix, is designed to provide a way to build and
+    query vector databases for applications in natural language processing
+    (NLP) and large language models (LLMs). It allows users to store and
+    retrieve dense vector embeddings for text strings.
+  EOT
+
+  test_dir   'spec'
+  ignore     '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.AppleDouble', '.bundle',
+    '.yardoc', 'doc', 'tags', 'errors.lst', 'cscope.out', 'coverage', 'tmp',
+    'yard'
+  package_ignore '.all_images.yml', '.tool-versions', '.gitignore', 'VERSION',
+     '.rspec', *Dir.glob('.github/**/*', File::FNM_DOTMATCH)
+  readme     'README.md'
+
+  required_ruby_version  '~> 3.1'
+
+  dependency 'infobar',       '~> 0.8'
+  dependency 'json',          '~> 2.0'
+  dependency 'tins',          '~> 1.34'
+  dependency 'sqlite-vec',    '~> 0.0'
+  dependency 'sqlite3',       '~> 2.0', '>= 2.0.1'
+  dependency 'kramdown-ansi', '~> 0.0', '>= 0.0.1'
+  dependency 'numo-narray',   '~> 0.9'
+  dependency 'redis',         '~> 5.0'
+  dependency 'more_math',     '~> 1.1'
+
+  development_dependency 'all_images', '~> 0.6'
+  development_dependency 'rspec',      '~> 3.2'
+  development_dependency 'kramdown',   '~> 2.0'
+  development_dependency 'debug'
+  development_dependency 'simplecov'
+
+  licenses << 'MIT'
+
+  clobber 'coverage'
+end

data/documentrix.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+# stub: documentrix 0.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "documentrix".freeze
+  s.version = "0.0.0".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Florian Frank".freeze]
+  s.date = "2024-12-06"
+  s.description = "The Ruby library, Documentrix, is designed to provide a way to build and\nquery vector databases for applications in natural language processing\n(NLP) and large language models (LLMs). It allows users to store and\nretrieve dense vector embeddings for text strings.\n".freeze
+  s.email = "flori@ping.de".freeze
+  s.extra_rdoc_files = ["README.md".freeze, "lib/documentrix.rb".freeze, "lib/documentrix/documents.rb".freeze, "lib/documentrix/documents/cache/common.rb".freeze, "lib/documentrix/documents/cache/memory_cache.rb".freeze, "lib/documentrix/documents/cache/records.rb".freeze, "lib/documentrix/documents/cache/redis_backed_memory_cache.rb".freeze, "lib/documentrix/documents/cache/redis_cache.rb".freeze, "lib/documentrix/documents/cache/sqlite_cache.rb".freeze, "lib/documentrix/documents/splitters/character.rb".freeze, "lib/documentrix/documents/splitters/semantic.rb".freeze, "lib/documentrix/utils.rb".freeze, "lib/documentrix/utils/colorize_texts.rb".freeze, "lib/documentrix/utils/math.rb".freeze, "lib/documentrix/utils/tags.rb".freeze, "lib/documentrix/version.rb".freeze]
+  s.files = [".yardopts".freeze, "Gemfile".freeze, "README.md".freeze, "Rakefile".freeze, "documentrix.gemspec".freeze, "lib/documentrix.rb".freeze, "lib/documentrix/documents.rb".freeze, "lib/documentrix/documents/cache/common.rb".freeze, "lib/documentrix/documents/cache/memory_cache.rb".freeze, "lib/documentrix/documents/cache/records.rb".freeze, "lib/documentrix/documents/cache/redis_backed_memory_cache.rb".freeze, "lib/documentrix/documents/cache/redis_cache.rb".freeze, "lib/documentrix/documents/cache/sqlite_cache.rb".freeze, "lib/documentrix/documents/splitters/character.rb".freeze, "lib/documentrix/documents/splitters/semantic.rb".freeze, "lib/documentrix/utils.rb".freeze, "lib/documentrix/utils/colorize_texts.rb".freeze, "lib/documentrix/utils/math.rb".freeze, "lib/documentrix/utils/tags.rb".freeze, "lib/documentrix/version.rb".freeze, "spec/assets/embeddings.json".freeze, "spec/documentrix/documents/cache/memory_cache_spec.rb".freeze, "spec/documentrix/documents/cache/redis_backed_memory_cache_spec.rb".freeze, "spec/documentrix/documents/cache/redis_cache_spec.rb".freeze, "spec/documentrix/documents/cache/sqlite_cache_spec.rb".freeze, "spec/documentrix/documents/splitters/character_spec.rb".freeze, "spec/documentrix/documents/splitters/semantic_spec.rb".freeze, "spec/documents_spec.rb".freeze, "spec/spec_helper.rb".freeze, "spec/utils/colorize_texts_spec.rb".freeze, "spec/utils/tags_spec.rb".freeze]
+  s.homepage = "https://github.com/flori/documentrix".freeze
+  s.licenses = ["MIT".freeze]
+  s.rdoc_options = ["--title".freeze, "Documentrix - \"Ruby library for embedding vector database".freeze, "--main".freeze, "README.md".freeze]
+  s.required_ruby_version = Gem::Requirement.new("~> 3.1".freeze)
+  s.rubygems_version = "3.5.23".freeze
+  s.summary = "\"Ruby library for embedding vector database".freeze
+  s.test_files = ["spec/documentrix/documents/cache/memory_cache_spec.rb".freeze, "spec/documentrix/documents/cache/redis_backed_memory_cache_spec.rb".freeze, "spec/documentrix/documents/cache/redis_cache_spec.rb".freeze, "spec/documentrix/documents/cache/sqlite_cache_spec.rb".freeze, "spec/documentrix/documents/splitters/character_spec.rb".freeze, "spec/documentrix/documents/splitters/semantic_spec.rb".freeze, "spec/documents_spec.rb".freeze, "spec/spec_helper.rb".freeze, "spec/utils/colorize_texts_spec.rb".freeze, "spec/utils/tags_spec.rb".freeze]
+
+  s.specification_version = 4
+
+  s.add_development_dependency(%q<gem_hadar>.freeze, ["~> 1.19".freeze])
+  s.add_development_dependency(%q<all_images>.freeze, ["~> 0.6".freeze])
+  s.add_development_dependency(%q<rspec>.freeze, ["~> 3.2".freeze])
+  s.add_development_dependency(%q<kramdown>.freeze, ["~> 2.0".freeze])
+  s.add_development_dependency(%q<debug>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<simplecov>.freeze, [">= 0".freeze])
+  s.add_runtime_dependency(%q<infobar>.freeze, ["~> 0.8".freeze])
+  s.add_runtime_dependency(%q<json>.freeze, ["~> 2.0".freeze])
+  s.add_runtime_dependency(%q<tins>.freeze, ["~> 1.34".freeze])
+  s.add_runtime_dependency(%q<sqlite-vec>.freeze, ["~> 0.0".freeze])
+  s.add_runtime_dependency(%q<sqlite3>.freeze, ["~> 2.0".freeze, ">= 2.0.1".freeze])
+  s.add_runtime_dependency(%q<kramdown-ansi>.freeze, ["~> 0.0".freeze, ">= 0.0.1".freeze])
+  s.add_runtime_dependency(%q<numo-narray>.freeze, ["~> 0.9".freeze])
+  s.add_runtime_dependency(%q<redis>.freeze, ["~> 5.0".freeze])
+  s.add_runtime_dependency(%q<more_math>.freeze, ["~> 1.1".freeze])
+end

data/lib/documentrix/documents/cache/common.rb

@@ -0,0 +1,43 @@
+module Documentrix::Documents::Cache::Common
+  include Documentrix::Utils::Math
+
+  # The initialize method sets up the Documentrix::Documents::Cache instance's
+  # by setting its prefix attribute to the given value.
+  #
+  # @param [String] prefix the string to be used as the prefix for this cache
+  def initialize(prefix:)
+    self.prefix = prefix
+  end
+
+  attr_accessor :prefix # current prefix defined for the cache
+
+  # Returns an array of collection names that match the given prefix.
+  #
+  # @param prefix [String] a string to search for in collection names
+  # @return [Array<Symbol>] an array of matching collection names
+  def collections(prefix)
+    unique = Set.new
+    full_each do |key, _|
+      key =~ /\A#{prefix}(.+)-/ or next
+      unique << $1
+    end
+    unique.map(&:to_sym)
+  end
+
+  # Returns a string representing the given `key` prefixed with the defined
+  # prefix.
+  #
+  # @param key [String] the key to join with the prefix
+  # @return [String] the joined string of prefix and key
+  def pre(key)
+    [ @prefix, key ].join
+  end
+
+  # Returns a string with the prefix removed from the given `key`.
+  #
+  # @param key [String] the input string containing the prefix.
+  # @return [String] the input string without the prefix.
+  def unpre(key)
+    key.sub(/\A#@prefix/, '')
+  end
+end

data/lib/documentrix/documents/cache/memory_cache.rb

@@ -0,0 +1,91 @@
+require 'documentrix/documents/cache/common'
+
+class Documentrix::Documents::MemoryCache
+  include Documentrix::Documents::Cache::Common
+
+  # The initialize method sets up the Documentrix::Documents::Cache instance's
+  # by setting its prefix attribute to the given value.
+  #
+  # @param [String] prefix the string to be used as the prefix for this cache
+  def initialize(prefix:)
+    super(prefix:)
+    @data   = {}
+  end
+
+  # The [] method retrieves the value associated with the given key from the
+  # cache.
+  #
+  # @param [String] key the key to look up in the cache
+  #
+  # @return [Object] the cached value, or nil if not found
+  def [](key)
+    @data[pre(key)]
+  end
+
+  # The []= method sets the value for a given key in the cache.
+  #
+  # @param [String] key the key to set
+  # @param [Hash] value the value to associate with the key
+  #
+  # @return [void]
+  def []=(key, value)
+    @data[pre(key)] = value
+  end
+
+  # The key? method checks if the given key exists in the cache.
+  #
+  # @param [String] key the key to check for existence
+  #
+  # @return [TrueClass, FalseClass] true if the key exists, false otherwise
+  def key?(key)
+    @data.key?(pre(key))
+  end
+
+  # The delete method removes the key-value pair from the cache by deleting it
+  # from the underlying data structure.
+  #
+  # @param [String] key the key of the value to be deleted
+  #
+  # @return [TrueClass, FalseClass] true if the key was found and deleted, false otherwise.
+  def delete(key)
+    !!@data.delete(pre(key))
+  end
+
+  # The size method returns the number of elements in the cache, that is the
+  # ones prefixed with `prefix`.
+  #
+  # @return [ Integer ] The count of elements in the cache.
+  def size
+    count
+  end
+
+  # The clear method removes all records from the cache that have keys starting
+  # with the prefix `prefix`.
+  #
+  # @return [ Documentrix::Documents::MemoryCache ] self
+  def clear
+    @data.delete_if { |key, _| key.start_with?(@prefix) }
+    self
+  end
+
+  # The each method iterates over the cache's keys and values under a given
+  # prefix `prefix`.
+  #
+  # @yield [key, value] Each key-value pair in the cache
+  #
+  # @return [void]
+  def each(&block)
+    @data.select { |key,| key.start_with?(@prefix) }.each(&block)
+  end
+  include Enumerable
+
+  # The full_each method iterates over the data hash and yields each key-value
+  # pair to the given block regardless of the prefix `prefix`.
+  #
+  # @yield [key, value] Each key-value pair in the data hash
+  #
+  # @return [void]
+  def full_each(&block)
+    @data.each(&block)
+  end
+end

data/lib/documentrix/documents/cache/records.rb

@@ -0,0 +1,145 @@
+module Documentrix::Documents::Cache::Records
+  class Record < JSON::GenericObject
+    # The initialize method sets default values for the text and norm
+    # attributes.
+    #
+    # @param [Hash] options A hash containing optional parameters.
+    def initialize(options = {})
+      super
+      self.text ||= ''
+      self.norm ||= 0.0
+    end
+
+    # The to_s method returns a string representation of the object.
+    #
+    # @return [String] A string containing the text and tags of the record,
+    # along with its similarity score.
+    def to_s
+      my_tags = tags_set
+      my_tags.empty? or my_tags = " #{my_tags}"
+      "#<#{self.class} #{text.inspect}#{my_tags} #{similarity || 'n/a'}>"
+    end
+
+    # The tags_set method creates a new Documentrix::Utils::Tags object from
+    # the tags and source of this instance.
+    #
+    # @return [ Documentrix::Utils::Tags ] a new Documentrix::Utils::Tags object
+    def tags_set
+      Documentrix::Utils::Tags.new(tags, source:)
+    end
+
+    # The == method compares this record with another one by comparing their
+    # text fields.
+    #
+    # @param other [ Documentrix::Documents::Record ] the other record to compare with
+    #
+    # @return [ FalseClass, TrueClass ] true if both records have the same
+    #         text, false otherwise.
+    def ==(other)
+      text == other.text
+    end
+
+    alias inspect to_s
+  end
+
+  module RedisFullEach
+    # The full_each method iterates over all records in the cache and yields
+    # them to the block.
+    #
+    # @yield [ key, value ] where key is the record's key and value is the record itself
+    def full_each(&block)
+      redis.scan_each(match: [ Documentrix::Documents, ?* ] * ?-) do |key|
+        value = redis.get(key) or next
+        value = JSON(value, object_class: Documentrix::Documents::Record)
+        block.(key, value)
+      end
+    end
+  end
+
+  module FindRecords
+    # The find_records method finds records that match the given needle and
+    # tags.
+    #
+    # @param needle [ Array ] an array containing the embedding vector
+    # @param tags [ String, Array ] a string or array of strings representing the tags to search for
+    # @param max_records [ Integer ] the maximum number of records to return
+    #
+    # @yield [ record ]
+    #
+    # @return [ Array<Documentrix::Documents::Records> ] an array containing the matching records
+    def find_records(needle, tags: nil, max_records: nil)
+      tags    = Documentrix::Utils::Tags.new(Array(tags)).to_a
+      records = self
+      if tags.present?
+        records = records.select { |_key, record| (tags & record.tags).size >= 1 }
+      end
+      needle_norm = norm(needle)
+      records     = records.sort_by { |key, record|
+        record.key        = key
+        record.similarity = cosine_similarity(
+          a: needle,
+          b: record.embedding,
+          a_norm: needle_norm,
+          b_norm: record.norm,
+        )
+      }
+      records.transpose.last&.reverse.to_a
+    end
+  end
+
+  module Tags
+    # The clear method removes all records that match the given tags from the
+    # cache.
+    #
+    # @param tags [ Array<String> ] an array of tag names
+    #
+    # @example
+    #   documents.clear(tags: %w[ foo bar ])
+    #
+    # @return [ self ]
+    def clear(tags: nil)
+      tags = Documentrix::Utils::Tags.new(tags).to_a
+      if tags.present?
+        if respond_to?(:clear_for_tags)
+          clear_for_tags(tags)
+        else
+          each do |key, record|
+            if (tags & record.tags.to_a).size >= 1
+              delete(unpre(key))
+            end
+          end
+        end
+      else
+        super()
+      end
+      self
+    end
+
+    # The tags method returns an array of unique tags from all records.
+    #
+    # @return [Documentrix::Utils::Tags] An instance of
+    #         Documentrix::Utils::Tags containing the unique tags.
+    def tags
+      if defined? super
+        super
+      else
+        each_with_object(Documentrix::Utils::Tags.new) do |(_, record), t|
+          record.tags.each do |tag|
+            t.add(tag, source: record.source)
+          end
+        end
+      end
+    end
+    def tags
+      if defined? super
+        super
+      else
+        each_with_object(Documentrix::Utils::Tags.new) do |(_, record), t|
+          record.tags.each do |tag|
+            t.add(tag, source: record.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/documentrix/documents/cache/redis_backed_memory_cache.rb

@@ -0,0 +1,64 @@
+require 'redis'
+
+class Documentrix::Documents
+  class RedisBackedMemoryCache < MemoryCache
+
+    # The initialize method sets up the RedisBackedMemoryCache cache by
+    # creating a new instance and populating it with data from the internally
+    # created RedisCache.
+    #
+    # @param prefix [String] The prefix for keys in the Redis cache
+    # @param url [String] The URL of the Redis server (default: ENV['REDIS_URL'])
+    # @param object_class [Class] The class to use for deserializing values from Redis (default: nil)
+    #
+    # @raise [ArgumentError] If the redis_url environment variable is not set
+    def initialize(prefix:, url: ENV['REDIS_URL'], object_class: nil)
+      super(prefix:)
+      url or raise ArgumentError, 'require redis url'
+      @url, @object_class = url, object_class
+      @redis_cache = Documentrix::Documents::RedisCache.new(prefix:, url:, object_class:)
+      @redis_cache.extend(Documentrix::Documents::Cache::Records::RedisFullEach)
+      @redis_cache.full_each { |key, value| @data[key] = value }
+    end
+
+    attr_reader :object_class # the class of objects stored in the cache
+
+    # The redis method returns the Redis client instance used by the cache.
+    #
+    # @return [Redis] The Redis client instance
+    def redis
+      @redis_cache.redis
+    end
+
+    # The set method sets the value for a given key in memory and in Redis.
+    #
+    # @param [String] key the key to be set
+    # @param [Hash] value the hash containing the data to be stored
+    def []=(key, value)
+      super
+      redis.set(pre(key), JSON(value))
+    end
+
+    # The delete method removes a key from the cache by calling Redis's del
+    # method and then calling the superclass's delete method.
+    #
+    # @param [String] key the key to be deleted
+    #
+    # @return [FalseClass, TrueClass] true if the key was successfully deleted, false otherwise.
+    def delete(key)
+      result = redis.del(pre(key))
+      super && result == 1
+    end
+
+    # The clear method deletes all keys from the cache by scanning redis for
+    # keys that match the prefix `prefix` and then deleting them, then it does
+    # the same for the MemoryCache by calling its super.
+    #
+    # @return [self] self
+    def clear
+      redis.scan_each(match: "#@prefix*") { |key| redis.del(key) }
+      super
+      self
+    end
+  end
+end

data/lib/documentrix/documents/cache/redis_cache.rb

@@ -0,0 +1,128 @@
+require 'documentrix/documents/cache/common'
+require 'redis'
+
+class Documentrix::Documents::RedisCache
+  include Documentrix::Documents::Cache::Common
+
+  # The initialize method sets up the Documentrix::Documents::RedisCache
+  # instance's by setting its prefix attribute to the given value and
+  # initializing the Redis client.
+  #
+  # @param [String] prefix the string to be used as the prefix for this cache
+  # @param [String] url the URL of the Redis server (default: ENV['REDIS_URL'])
+  # @param [Class] object_class the class of objects stored in Redis (default: nil)
+  # @param [Integer] ex the expiration time in seconds (default: nil)
+  def initialize(prefix:, url: ENV['REDIS_URL'], object_class: nil, ex: nil)
+    super(prefix:)
+    url or raise ArgumentError, 'require redis url'
+    @url, @object_class, @ex = url, object_class, ex
+  end
+
+  attr_reader :object_class # the class of objects stored in the cache
+
+  # The redis method returns an instance of Redis client
+  #
+  # @return [Redis] An instance of Redis client
+  def redis
+    @redis ||= Redis.new(url: @url)
+  end
+
+  # The [](key) method retrieves the value associated with the given key from Redis.
+  #
+  # @param [String] key the string representation of the key
+  #
+  # @return [Object, nil] the retrieved value if it exists in Redis, or nil otherwise
+  def [](key)
+    value = redis.get(pre(key))
+    unless value.nil?
+      object_class ? JSON(value, object_class:) : JSON(value)
+    end
+  end
+
+  # The []= method sets the value associated with the given key in this cache instance.
+  #
+  # @param [String] key the string representation of the key
+  # @param [Object] value the object to be stored under the given key
+  #
+  # @return [Object] self
+  def []=(key, value)
+    set(key, value)
+  end
+
+  # The set method sets the value associated with the given key in this cache instance.
+  #
+  # @param [String] key the string representation of the key
+  # @param [Object] value the object to be stored under the given key
+  # @option ex [Integer] ex the expiration time in seconds (default: nil)
+  #
+  # @return [Object] self
+  def set(key, value, ex: nil)
+    ex ||= @ex
+    if !ex.nil? && ex < 1
+      redis.del(pre(key))
+    else
+      redis.set(pre(key), JSON.generate(value), ex:)
+    end
+    value
+  end
+
+  # The ttl method returns the time-to-live (TTL) value for the given key
+  #
+  # @param [String] key the string representation of the key
+  #
+  # @return [Integer, nil] the TTL value if it exists in Redis, or nil otherwise
+  def ttl(key)
+    redis.ttl(pre(key))
+  end
+
+  # The key? method checks if the given key exists in Redis by calling the
+  # redis.exists? method
+  #
+  # @param [String] key the string representation of the key
+  #
+  # @return [FalseClass, TrueClass] true if the key exists, false otherwise
+  def key?(key)
+    !!redis.exists?(pre(key))
+  end
+
+  # The delete method removes the key-value pair associated with the given key
+  # from this cache instance.
+  #
+  # @param [String] key the string representation of the key
+  #
+  # @return [FalseClass, TrueClass] true if the key was deleted successfully, false otherwise
+  def delete(key)
+    redis.del(pre(key)) == 1
+  end
+
+  # The size method returns the total number of keys stored in this cache
+  # instance, that is the ones with the prefix `prefix`.
+  #
+  # @return [Integer] The total count of keys
+  def size
+    s = 0
+    redis.scan_each(match: "#@prefix*") { |key| s += 1 }
+    s
+  end
+
+  # The clear method removes all key-value pairs associated with the given
+  # prefix from this cache instance.
+  #
+  # @return [Documentrix::Documents::RedisCache] self
+  def clear
+    redis.scan_each(match: "#@prefix*") { |key| redis.del(key) }
+    self
+  end
+
+  # The each method iterates over the cache keys with prefix `prefix` and
+  # yields each key-value pair to the given block.
+  #
+  # @yield [key, value] Each key-value pair in the cache
+  #
+  # @return [self] self
+  def each(&block)
+    redis.scan_each(match: "#@prefix*") { |key| block.(key, self[unpre(key)]) }
+    self
+  end
+  include Enumerable
+end