qdrant-ruby 0.9.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/qdrant/aliases.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Aliases < Base
+    PATH = "aliases"
+
+    # Get list of all aliases (for a collection)
+    def list
+      response = client.connection.get("aliases")
+      response.body
+    end
+  end
+end

data/lib/qdrant/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Base
+    attr_reader :client
+
+    def initialize(client:)
+      @client = client
+    end
+  end
+end

data/lib/qdrant/client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "forwardable"
+
+module Qdrant
+  class Client
+    extend Forwardable
+
+    attr_reader :url, :api_key, :adapter
+
+    def_delegators :service, :telemetry, :metrics, :locks, :set_lock
+
+    def initialize(
+      url:,
+      api_key: nil,
+      adapter: Faraday.default_adapter
+    )
+      @url = url
+      @api_key = api_key
+      @adapter = adapter
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: url) do |faraday|
+        if api_key
+          faraday.headers["api-key"] = api_key
+        end
+        faraday.request :json
+        faraday.response :json, content_type: /\bjson$/
+        faraday.adapter adapter
+      end
+    end
+
+    def aliases
+      @aliases ||= Qdrant::Aliases.new(client: self).list
+    end
+
+    def collections
+      @collections ||= Qdrant::Collections.new(client: self)
+    end
+
+    def snapshots
+      @snapshots ||= Qdrant::Snapshots.new(client: self)
+    end
+
+    def service
+      @service ||= Qdrant::Service.new(client: self)
+    end
+
+    def clusters
+      @clusters ||= Qdrant::Clusters.new(client: self)
+    end
+
+    def points
+      @points ||= Qdrant::Points.new(client: self)
+    end
+  end
+end

data/lib/qdrant/clusters.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Clusters < Base
+    PATH = "cluster"
+
+    # Get information about the current state and composition of the cluster
+    def info
+      response = client.connection.get(PATH)
+      response.body
+    end
+
+    # Tries to recover current peer Raft state.
+    def recover
+      response = client.connection.post("#{PATH}/recover")
+      response.body
+    end
+
+    # Remove peer from the cluster
+    def remove_peer(
+      peer_id:,
+      force: nil
+    )
+      response = client.connection.post("#{PATH}/recover") do |req|
+        req.params["force"] = force if force
+      end
+      response.body
+    end
+  end
+end

data/lib/qdrant/collections.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Collections < Base
+    PATH = "collections"
+
+    # Get list name of all existing collections
+    def list
+      response = client.connection.get(PATH)
+      response.body
+    end
+
+    # Get detailed information about specified existing collection
+    def get(collection_name:)
+      response = client.connection.get("#{PATH}/#{collection_name}")
+      response.body
+    end
+
+    # Create new collection with given parameters
+    def create(
+      collection_name:,
+      vectors:,
+      shard_number: nil,
+      replication_factor: nil,
+      write_consistency_factor: nil,
+      on_disk_payload: nil,
+      hnsw_config: nil,
+      wal_config: nil,
+      optimizers_config: nil,
+      init_from: nil,
+      quantization_config: nil
+    )
+      response = client.connection.put("#{PATH}/#{collection_name}") do |req|
+        req.body = {}
+        req.body["vectors"] = vectors
+        req.body["shard_number"] = shard_number unless shard_number.nil?
+        req.body["replication_factor"] = replication_factor unless replication_factor.nil?
+        req.body["write_consistency_factor"] = write_consistency_factor unless write_consistency_factor.nil?
+        req.body["on_disk_payload"] = on_disk_payload unless on_disk_payload.nil?
+        req.body["hnsw_config"] = hnsw_config unless hnsw_config.nil?
+        req.body["wal_config"] = wal_config unless wal_config.nil?
+        req.body["optimizers_config"] = optimizers_config unless optimizers_config.nil?
+        req.body["init_from"] = init_from unless init_from.nil?
+        req.body["quantization_config"] = quantization_config unless quantization_config.nil?
+      end
+
+      response.body
+    end
+
+    # Update parameters of the existing collection
+    def update(
+      collection_name:,
+      optimizers_config: nil,
+      params: nil
+    )
+      response = client.connection.patch("#{PATH}/#{collection_name}") do |req|
+        req.body = {}
+        req.body["optimizers_config"] = optimizers_config unless optimizers_config.nil?
+        req.body["params"] = params unless params.nil?
+      end
+
+      response.body
+    end
+
+    # Drop collection and all associated data
+    def delete(collection_name:)
+      response = client.connection.delete("#{PATH}/#{collection_name}")
+      response.body
+    end
+
+    # Get list of all aliases for a collection
+    def aliases(collection_name:)
+      response = client.connection.get("#{PATH}/#{collection_name}/aliases")
+      response.body
+    end
+
+    # Update aliases of the collections
+    def update_aliases(actions:)
+      response = client.connection.post("#{PATH}/aliases") do |req|
+        req.body = {
+          actions: actions
+        }
+      end
+
+      response.body
+    end
+
+    # Create index for field in collection.
+    def create_index(
+      collection_name:,
+      field_name:,
+      field_schema: nil
+    )
+      response = client.connection.put("#{PATH}/#{collection_name}/index") do |req|
+        req.body = {
+          field_name: field_name
+        }
+        req.body["field_schema"] = field_schema unless field_schema.nil?
+      end
+
+      response.body
+    end
+
+    # Delete field index for collection
+    def delete_index(
+      collection_name:,
+      field_name:
+    )
+      response = client.connection.delete("#{PATH}/#{collection_name}/index/#{field_name}")
+      response.body
+    end
+
+    # Get cluster information for a collection
+    def cluster_info(collection_name:)
+      response = client.connection.get("#{PATH}/#{collection_name}/cluster")
+      response.body
+    end
+
+    # Update collection cluster setup
+    def update_cluster(
+      collection_name:,
+      move_shard:
+    )
+      response = client.connection.post("#{PATH}/#{collection_name}/cluster") do |req|
+        req.body = {
+          move_shard: move_shard
+        }
+      end
+      response.body
+    end
+
+    # Download specified snapshot from a collection as a file
+    def download_snapshot(
+      collection_name:,
+      snapshot_name:,
+      filepath:
+    )
+      response = client.connection.get("#{PATH}/#{collection_name}/snapshots/#{snapshot_name}")
+      File.open(File.expand_path(filepath), "wb+") { |fp| fp.write(response.body) }
+    end
+
+    # Delete snapshot for a collection
+    def delete_snapshot(
+      collection_name:,
+      snapshot_name:
+    )
+      response = client.connection.delete("#{PATH}/#{collection_name}/snapshots/#{snapshot_name}")
+      response.body
+    end
+
+    # Create new snapshot for a collection
+    def create_snapshot(
+      collection_name:
+    )
+      response = client.connection.post("#{PATH}/#{collection_name}/snapshots")
+      response.body
+    end
+
+    # Get list of snapshots for a collection
+    def list_snapshots(
+      collection_name:
+    )
+      response = client.connection.get("collections/#{collection_name}/snapshots")
+      response.body
+    end
+
+    # Recover local collection data from a snapshot. This will overwrite any data, stored on this node, for the collection. If collection does not exist - it will be created.
+    def restore_snapshot(
+      collection_name:,
+      filepath:,
+      priority: nil,
+      wait: nil
+    )
+      response = client.connection.post("#{PATH}/#{collection_name}/snapshots/recover") do |req|
+        req.params["wait"] = wait unless wait.nil?
+
+        req.body = {
+          location: filepath
+        }
+        req.body["priority"] = priority unless priority.nil?
+      end
+      response.body
+    end
+  end
+end

data/lib/qdrant/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Error < StandardError
+  end
+end

data/lib/qdrant/points.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Points < Base
+    PATH = "points"
+
+    # Lists all data objects in reverse order of creation. The data will be returned as an array of objects.
+    def list(
+      collection_name:,
+      ids: nil,
+      with_payload: nil,
+      with_vector: nil,
+      consistency: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}") do |req|
+        req.params["consistency"] = consistency unless consistency.nil?
+
+        req.body = {}
+        req.body["ids"] = ids
+        req.body["with_payload"] = with_payload unless with_payload.nil?
+        req.body["with_vector"] = with_vector unless with_vector.nil?
+      end
+      response.body
+    end
+
+    # Perform insert + updates on points. If point with given ID already exists - it will be overwritten.
+    def upsert(
+      collection_name:,
+      wait: nil,
+      ordering: nil,
+      batch: nil,
+      points: nil
+    )
+      response = client.connection.put("collections/#{collection_name}/#{PATH}") do |req|
+        req.params = {}
+        req.params["wait"] = wait unless wait.nil?
+        req.params["ordering"] = ordering unless ordering.nil?
+
+        req.body = {}
+        req.body["batch"] = batch unless batch.nil?
+        req.body["points"] = points unless points.nil?
+      end
+      response.body
+    end
+
+    # Delete points
+    def delete(
+      collection_name:,
+      points:, wait: nil,
+      ordering: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/delete") do |req|
+        req.params["wait"] = wait unless wait.nil?
+        req.params["ordering"] = ordering unless ordering.nil?
+
+        req.body = {}
+        req.body["points"] = points
+      end
+      response.body
+    end
+
+    # Retrieve full information of single point by id
+    def get(
+      collection_name:,
+      id:,
+      consistency: nil
+    )
+      response = client.connection.get("collections/#{collection_name}/#{PATH}/#{id}") do |req|
+        req.params["consistency"] = consistency unless consistency.nil?
+      end
+      response.body
+    end
+
+    # Set payload values for points
+    def set_payload(
+      collection_name:,
+      payload:,
+      wait: nil,
+      ordering: nil,
+      points: nil,
+      filter: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/payload") do |req|
+        req.params["wait"] = wait unless wait.nil?
+        req.params["ordering"] = ordering unless ordering.nil?
+
+        req.body = {}
+        req.body["payload"] = payload
+        req.body["points"] = points unless points.nil?
+        req.body["filter"] = filter unless filter.nil?
+      end
+      response.body
+    end
+
+    # Replace full payload of points with new one
+    def overwrite_payload(
+      collection_name:,
+      payload:, wait: nil,
+      ordering: nil,
+      points: nil,
+      filter: nil
+    )
+      response = client.connection.put("collections/#{collection_name}/#{PATH}/payload") do |req|
+        req.params["wait"] = wait unless wait.nil?
+        req.params["ordering"] = ordering unless ordering.nil?
+
+        req.body = {}
+        req.body["payload"] = payload
+        req.body["points"] = points unless points.nil?
+        req.body["filter"] = filter unless filter.nil?
+      end
+      response.body
+    end
+
+    # Delete specified key payload for points
+    def clear_payload_keys(
+      collection_name:,
+      keys:, wait: nil,
+      ordering: nil,
+      points: nil,
+      filter: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/payload/delete") do |req|
+        req.params["wait"] = wait unless wait.nil?
+        req.params["ordering"] = ordering unless ordering.nil?
+
+        req.body = {}
+        req.body["keys"] = keys
+        req.body["points"] = points unless points.nil?
+        req.body["filter"] = filter unless filter.nil?
+      end
+      response.body
+    end
+
+    # Remove all payload for specified points
+    def clear_payload(
+      collection_name:,
+      wait: nil,
+      ordering: nil,
+      points: nil,
+      filter: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/payload/clear") do |req|
+        req.params["wait"] = wait unless wait.nil?
+        req.params["ordering"] = ordering unless ordering.nil?
+
+        req.body = {}
+        req.body["points"] = points unless points.nil?
+        req.body["filter"] = filter unless filter.nil?
+      end
+      response.body
+    end
+
+    # Scroll request - paginate over all points which matches given filtering condition
+    def scroll(
+      collection_name:,
+      limit:,
+      filter: nil,
+      offset: nil,
+      with_payload: nil,
+      with_vector: nil,
+      consistency: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/scroll") do |req|
+        req.params["consistency"] = consistency unless consistency.nil?
+
+        req.body = {}
+        req.body["limit"] = limit
+        req.body["filter"] = filter unless filter.nil?
+        req.body["offset"] = offset unless offset.nil?
+        req.body["with_payload"] = with_payload unless with_payload.nil?
+        req.body["with_vector"] = with_vector unless with_vector.nil?
+      end
+      response.body
+    end
+
+    # Retrieve closest points based on vector similarity and given filtering conditions
+    def search(
+      collection_name:,
+      vector:,
+      limit:,
+      filter: nil,
+      params: nil,
+      offset: nil,
+      with_payload: nil,
+      with_vector: nil,
+      score_threshold: nil,
+      consistency: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/search") do |req|
+        req.params["consistency"] = consistency unless consistency.nil?
+
+        req.body = {}
+        req.body["vector"] = vector
+        req.body["limit"] = limit
+        req.body["filter"] = filter unless filter.nil?
+        req.body["params"] = params unless params.nil?
+        req.body["offset"] = offset unless offset.nil?
+        req.body["with_payload"] = with_payload unless with_payload.nil?
+        req.body["with_vector"] = with_vector unless with_vector.nil?
+        req.body["score_threshold"] = score_threshold unless score_threshold.nil?
+      end
+      response.body
+    end
+
+    # Retrieve by batch the closest points based on vector similarity and given filtering conditions
+    def batch_search(
+      collection_name:,
+      searches:,
+      consistency: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/search/batch") do |req|
+        req.params["consistency"] = consistency unless consistency.nil?
+
+        req.body = {}
+        req.body["searches"] = searches
+      end
+      response.body
+    end
+
+    # Look for the points which are closer to stored positive examples and at the same time further to negative examples.
+    def recommend(
+      collection_name:,
+      positive:,
+      limit:,
+      negative: nil,
+      filter: nil,
+      params: nil,
+      offset: nil,
+      with_payload: nil,
+      with_vector: nil,
+      score_threshold: nil,
+      using: nil,
+      lookup_from: nil,
+      consistency: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/recommend") do |req|
+        req.params["consistency"] = consistency unless consistency.nil?
+
+        req.body = {}
+        req.body["positive"] = positive
+        req.body["negative"] = negative unless negative.nil?
+        req.body["limit"] = limit
+        req.body["filter"] = filter unless filter.nil?
+        req.body["params"] = params unless params.nil?
+        req.body["offset"] = offset unless offset.nil?
+        req.body["with_payload"] = with_payload unless with_payload.nil?
+        req.body["with_vector"] = with_vector unless with_vector.nil?
+        req.body["score_threshold"] = score_threshold unless score_threshold.nil?
+        req.body["using"] = using unless using.nil?
+        req.body["lookup_from"] = lookup_from unless lookup_from.nil?
+      end
+      response.body
+    end
+
+    # Look for the points which are closer to stored positive examples and at the same time further to negative examples.
+    def batch_recommend(
+      collection_name:,
+      searches:,
+      consistency: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/recommend/batch") do |req|
+        req.params["consistency"] = consistency unless consistency.nil?
+
+        req.body = {}
+        req.body["searches"] = searches
+      end
+      response.body
+    end
+
+    # Count points which matches given filtering condition
+    def count(
+      collection_name:,
+      filter: nil,
+      exact: nil
+    )
+      response = client.connection.post("collections/#{collection_name}/#{PATH}/count") do |req|
+        req.body = {}
+        req.body["filter"] = filter unless filter.nil?
+        req.body["exact"] = filter unless exact.nil?
+      end
+      response.body
+    end
+  end
+end

data/lib/qdrant/service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Service < Base
+    # Collect telemetry data including app info, system info, collections info, cluster info, configs and statistics
+    def telemetry(
+      anonymize: nil
+    )
+      response = client.connection.get("telemetry") do |req|
+        req.params["anonymize"] = anonymize if anonymize
+      end
+      response.body
+    end
+
+    # Collect metrics data including app info, collections info, cluster info and statistics
+    def metrics(
+      anonymize: nil
+    )
+      response = client.connection.get("metrics") do |req|
+        req.params["anonymize"] = anonymize if anonymize
+      end
+      response.body
+    end
+
+    # Set lock options. If write is locked, all write operations and collection creation are forbidden. Returns previous lock options
+    def set_lock(
+      write:,
+      error_message: nil
+    )
+      response = client.connection.post("locks") do |req|
+        req.body = {
+          write: write
+        }
+        req.body["error_message"] = error_message if error_message
+      end
+      response.body
+    end
+
+    # Get lock options. If write is locked, all write operations and collection creation are forbidden
+    def locks
+      response = client.connection.get("locks")
+      response.body
+    end
+  end
+end

data/lib/qdrant/snapshots.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Qdrant
+  class Snapshots < Base
+    PATH = "snapshots"
+
+    # Get list of snapshots of the whole storage
+    def list
+      response = client.connection.get(PATH)
+      response.body
+    end
+
+    # Create new snapshot of the whole storage
+    def create
+      response = client.connection.post(PATH)
+      response.body
+    end
+
+    # Delete snapshot of the whole storage
+    def delete(
+      snapshot_name:
+    )
+      response = client.connection.delete("#{PATH}/#{snapshot_name}")
+      response.body
+    end
+
+    # Download specified snapshot of the whole storage as a file
+    def download(
+      snapshot_name:,
+      filepath:
+    )
+      response = client.connection.get("#{PATH}/#{snapshot_name}")
+      File.open(File.expand_path(filepath), "wb+") { |fp| fp.write(response.body) }
+    end
+  end
+end

data/lib/qdrant/version.rb

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