milvus 0.9.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0b1a3fa88ea1e79f7a139441dc0665e4631ecf160a9d1507a556ef2e3aedb74
-  data.tar.gz: 1a215e718b86ffb2eab1b103d60d02b60ef493f90c88bcb28e05f0f1f6d07fa4
+  metadata.gz: 4333b7321ee1e40f8f390692f6e25ce991837cd6b51bf6dfb4eef48fcfc826e9
+  data.tar.gz: c84d6a7f8be503c0009676a0d659d43bc5e443442f49a9bc6d96824da5904579
 SHA512:
-  metadata.gz: d41d1ddf7d468d69b857bf07fc70926dca0193656768359250e038340211c4798e44390b337edcbee632a8b9e5a104fd082a2b506e0fa90a46c48627a55d4ef6
-  data.tar.gz: fbbc287d804be3babdd0ff9f3a08bd0ebacfcfa3e7d2338397d431784e4b2b5143889d5fc067a82ab33d06a93525bbd9a2f772a949238dbbcbe8bddff75cb19d
+  metadata.gz: 2fffcbee8f0596ab3b65d12992a6323518a1a9ee1cb5c6c5d8437bbabcfa123acc8c777a189932fdc1be1b9b283c14f449e29dab27dc6b23d5c0dc7f333c3a42
+  data.tar.gz: a6d589ffa1c4e2b1e95eb74d1a089727a51adfdd265e852db52bf0558baeceb3f8e78b3fd53133efffce212c683bc38a5dc54bb5b0cc6662e32c74180ca7b4db

data/.env.example

@@ -0,0 +1,2 @@
+MILVUS_URL=http://localhost:19530
+MILVUS_API_KEY=

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
-## [0.1.0] - 2023-04-20
+## [0.10.0] - 2024-07-04 🇺🇸
+- BREAKING: Switched the gem to use newer V2 API with different endpoints and corresponding endpoints.
 
+## [0.9.3] - 2023-07-01
+
+## [0.9.2] - 2023-08-10
+
+## [0.9.1] - 2023-05-10
+
+## [0.9.0] - 2023-04-21
 - Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    milvus (0.9.3)
+    milvus (0.10.0)
       faraday (>= 2.0.1, < 3)
 
 GEM
@@ -68,11 +68,7 @@ GEM
     unicode-display_width (2.4.2)
 
 PLATFORMS
-  arm64-darwin-23
-  x86_64-darwin-19
-  x86_64-darwin-21
-  x86_64-darwin-22
-  x86_64-linux
+  ruby
 
 DEPENDENCIES
   milvus!
@@ -82,4 +78,4 @@ DEPENDENCIES
   standard (~> 1.27.0)
 
 BUNDLED WITH
-   2.4.0
+   2.5.14

data/README.md

@@ -1,8 +1,8 @@
 # Milvus
 
 <p>
-    <img alt='Milvus logo' src='https://res.cloudinary.com/crunchbase-production/image/upload/c_lpad,f_auto,q_auto:eco,dpr_1/cqpyxcuzl6gwqjjwzamt' height='50' />
-    +&nbsp;&nbsp;
+    <img alt='Milvus logo' src='https://milvus.io/images/milvus_logo.svg' height='50' />
+    &nbsp;&nbsp;
     <img alt='Ruby logo' src='https://user-images.githubusercontent.com/541665/230231593-43861278-4550-421d-a543-fd3553aac4f6.png' height='40' />
 </p>
 
@@ -10,11 +10,17 @@ Ruby wrapper for the Milvus vector search database API.
 
 Part of the [Langchain.rb](https://github.com/andreibondarev/langchainrb) stack.
 
+Available for paid consulting engagements! [Email me](mailto:andrei@sourcelabs.io).
+
 ![Tests status](https://github.com/andreibondarev/milvus/actions/workflows/ci.yml/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/milvus.svg)](https://badge.fury.io/rb/milvus)
 [![Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/milvus)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/andreibondarev/milvus/blob/main/LICENSE.txt)
 [![](https://dcbadge.vercel.app/api/server/WDARp7J2n8?compact=true&style=flat)](https://discord.gg/WDARp7J2n8)
+[![X](https://img.shields.io/twitter/url/https/twitter.com/cloudposse.svg?style=social&label=Follow%20%40rushing_andrei)](https://twitter.com/rushing_andrei)
+
+## API Docs
+https://docs.zilliz.com/reference/restful/data-plane-v2
 
 ## Installation
 
@@ -34,14 +40,28 @@ If bundler is not being used to manage dependencies, install the gem by executin
 require 'milvus'
 
 client = Milvus::Client.new(
-    url: 'http://localhost:9091'
+    url: 'http://localhost:19530'
 )
 ```
 
 ### Using the Collections endpoints
+```ruby
+# Check if the collection exists.
+client.collections.has(collection_name: "book")
+```
+
+```ruby
+# Rename a collection.
+client.collections.rename(collection_name: "book", new_collection_name: "note")
+```
+
+```ruby
+# Get collection stats
+client.collections.get_stats(collection_name: "book")
+```
 
 ```ruby
-# Data types: "boolean", "int8", "int16", "int32", "int64", "float", "double", "string", "varchar", "binary_vector", "float_vector"
+# Data types: https://github.com/patterns-ai-core/milvus/blob/main/lib/milvus/constants.rb
 
 # Creating a new collection schema
 client.collections.create(
@@ -50,46 +70,47 @@ client.collections.create(
   auto_id: false,
   fields: [
     {
-      "name": "book_id",
+      "fieldName": "book_id",
       "description": "book id",
-      "is_primary_key": true,
+      "isPrimary": true,
       "autoID": false,
-      "data_type": Milvus::DATA_TYPES["int64"]
+      "dataType": "Int64"
     },
     {
-      "name": "word_count",
+      "fieldName": "word_count",
       "description": "count of words",
-      "is_primary_key": false,
-      "data_type": Milvus::DATA_TYPES["int64"]
+      "isPrimary": false,
+      "dataType": "Int64"
     },
     {
-      "name": "book_intro",
+      "fieldName": "book_intro",
       "description": "embedded vector of book introduction",
-      "data_type": Milvus::DATA_TYPES["binary_vector"],
-      "is_primary_key": false,
-      "type_params": [
-        {
-          "key": "dim",
-          "value": "2"
-        }
-      ]
+      "dataType": "FloatVector",
+      "isPrimary": false,
+      "elementTypeParams": {
+        "dim": "2"
+      }
     }
   ]
 )
 ```
 ```ruby
-# Get the collection info
-client.collections.get(collection_name: "book")
+# Descrbie the collection
+client.collections.describe(collection_name: "book")
 ```
 ```ruby
-# Delete the collection
-client.collections.delete(collection_name: "book")
+# Drop the collection
+client.collections.drop(collection_name: "book")
 ```
 ```ruby
 # Load the collection to memory before a search or a query
 client.collections.load(collection_name: "book")
 ```
 ```ruby
+# List all collections in the specified database.
+client.collections.list
+```
+```ruby
 # Release a collection from memory after a search or a query to reduce memory usage
 client.collections.release(collection_name: "book")
 ```
@@ -140,91 +161,126 @@ client.entities.compact_status(
 # => {"status"=>{}, "state"=>2}
 ```
 
-### Indices
+### Indexes
 ```ruby
-client.indices.create(
-  collection_name: "book",
-  field_name: "book_intro",
-  extra_params: [
-    { key: "metric_type", "value": "L2" },
-    { key: "index_type", "value": "IVF_FLAT" },
-    { key: "params", "value": "{\"nlist\":1024}" }
-  ]
+# Create an index
+index_params = {
+  fieldName: "example_field",
+  indexType: "IVF_FLAT",
+  metricType: "L2",
+  params: { nlist: 100 }
+}
+
+client.indexes.create(
+  collection_name: "example_collection",
+  index_params: index_params
 )
 ```
 ```ruby
-collection.indices.create(
-  field_name: "book_name", 
-  index_name: "scalar_index",
+# Describe an index
+client.indexes.describe(
+  collection_name: "example_collection",
+  index_name: "example_index"
 )
 ```
 ```ruby
-client.indices.delete(
-  collection_name: "book",
-  field_name: "book_intro"
+# List indexes
+client.indexes.list(
+  collection_name: "example_collection"
+)
+```
+```ruby
+# Drop an index
+client.indexes.drop(
+  collection_name: "example_collection",
+  index_name: "example_index"
 )
 ```
 
-### Search & Querying
+### Search, Querying & Hybrid Search
 ```ruby
-client.search(
-  collection_name: "book",
-  output_fields: ["book_id"], # optional
-  anns_field: "book_intro",
-  top_k: "2",
-  params: "{\"nprobe\": 10}",
-  metric_type: "L2",
-  round_decimal: "-1",
-  vectors: [ [0.1,0.2] ],
-  dsl_type: 1
+client.entities.search(
+  collection_name: "recipes",
+  anns_field: "vectors",
+  data: [embedding],
+  filter: "id in [450847466900987454]"
 )
 ```
 ```ruby
-client.query(
-  collection_name: "book",
-  output_fields: ["book_id", "book_intro"],
-  expr: "book_id in [2,4,6,8]"
+client.entities.query(
+  collection_name: "recipes",
+  filter: "id in [450847466900987455, 450847466900987454]"
+)
+```
+```ruby
+client.entities.hybrid_search(
+  collection_name: "recipes",
+  search: [{
+    filter: "id in [450847466900987455]",
+    data: [embedding],
+    annsField: "vectors",
+    limit: 10,
+    outputFields: ["content", "id"]
+  }],
+  rerank: {
+    "strategy": "rrf",
+    "params": {
+      "k": 10
+    }
+  },
+  limit: 10,
+  output_fields: ["content", "id"]
 )
 ```
 
 ### Partitions
 ```ruby
-client.partitions.create(
-  "collection_name": "book",
-  "partition_name": "novel"
+# List partitions
+client.partitions.list(
+  collection_name: "example_collection"
 )
 ```
 ```ruby
-client.partitions.get(
-  "collection_name": "book",
-  "partition_name": "novel"
+# Create a partition
+client.partitions.create(
+  collection_name: "example_collection",
+  partition_name: "example_partition"
 )
 ```
 ```ruby
-client.partitions.delete(
-  "collection_name": "book",
-  "partition_name": "novel"
+# Check if a partition exists
+client.partitions.has(
+  collection_name: "example_collection",
+  partition_name: "example_partition"
 )
 ```
 ```ruby
+# Load partition data into memory
 client.partitions.load(
-  "collection_name": "book",
-  "partition_names": ["novel"],
-  "replica_number": 1
+  collection_name: "example_collection",
+  partition_names: ["example_partition"]
 )
 ```
 ```ruby
+# Release partition data from memory
 client.partitions.release(
-  "collection_name": "book",
-  "partition_names": ["novel"],
-  "replica_number": 1
+  collection_name: "example_collection",
+  partition_names: ["example_partition"]
 )
 ```
-
-### Health
 ```ruby
-# Live determines whether the application is alive. It can be used for Kubernetes liveness probe.
-client.health
+# Get statistics of a partition
+client.partitions.get_stats(
+  collection_name: "example_collection",
+  partition_name: "example_partition"
+)
+```
+```ruby
+# Drop a partition
+client.partitions.drop(
+  collection_name: "example_collection",
+  partition_name: "example_partition"
+)
 ```
 
 ## Development
@@ -235,7 +291,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/andreibondarev/milvus.
+Bug reports and pull requests are welcome on GitHub at https://github.com/patterns-ai-core/milvus.
 
 ## License
 

data/lib/milvus/client.rb

@@ -6,20 +6,13 @@ module Milvus
   class Client
     attr_reader :url, :api_key
 
-    API_VERSION = "api/v1"
+    API_VERSION = "v2/vectordb"
 
-    def initialize(
-      url:,
-      api_key: nil
-    )
+    def initialize(url:, api_key: nil)
       @url = url
       @api_key = api_key
     end
 
-    def health
-      @health ||= Milvus::Health.new(client: self).get
-    end
-
     def collections
       @schema ||= Milvus::Collections.new(client: self)
     end
@@ -32,16 +25,8 @@ module Milvus
       @entities ||= Milvus::Entities.new(client: self)
     end
 
-    def indices
-      @indices ||= Milvus::Indices.new(client: self)
-    end
-
-    def search(...)
-      @search ||= Milvus::Search.new(client: self).post(...)
-    end
-
-    def query(...)
-      @query ||= Milvus::Query.new(client: self).post(...)
+    def indexes
+      @indexes ||= Milvus::Indexes.new(client: self)
     end
 
     def connection

data/lib/milvus/collections.rb

@@ -2,20 +2,67 @@
 
 module Milvus
   class Collections < Base
-    PATH = "collection"
+    PATH = "collections"
+
+    # This operation checks whether a collection exists.
+    #
+    # @param collection_name [String] The name of the collection to check.
+    # @return [Hash] Server response
+    def has(collection_name:)
+      response = client.connection.post("#{PATH}/has") do |req|
+        req.body = {
+          collectionName: collection_name
+        }.to_json
+      end
+      response.body
+    end
+
+    # This operation renames an existing collection and optionally moves the collection to a new database.
+    #
+    # @param collection_name [String] The name of the collection to rename.
+    # @param new_collection_name [String] The new name of the collection.
+    # @return [Hash] Server response
+    def rename(collection_name:, new_collection_name:)
+      response = client.connection.post("#{PATH}/rename") do |req|
+        req.body = {
+          collectionName: collection_name,
+          newCollectionName: new_collection_name
+        }
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation gets the number of entities in a collection.
+    #
+    # @param collection_name [String] The name of the collection to get the count of.
+    # @return [Hash] Server response
+    def get_stats(collection_name:)
+      response = client.connection.post("#{PATH}/get_stats") do |req|
+        req.body = {
+          collectionName: collection_name
+        }.to_json
+      end
+      response.body
+    end
 
     # Create a Collection
+    #
+    # @param collection_name [String] The name of the collection to create.
+    # @param auto_id [Boolean] Whether to automatically generate IDs for the collection.
+    # @param description [String] A description of the collection.
+    # @param fields [Array<Hash>] The fields of the collection.
+    # @return [Hash] Server response
     def create(
       collection_name:,
       auto_id:,
       description:,
       fields:
     )
-      response = client.connection.post(PATH) do |req|
+      response = client.connection.post("#{PATH}/create") do |req|
         req.body = {
-          collection_name: collection_name,
+          collectionName: collection_name,
           schema: {
-            auto_id: auto_id,
+            autoId: auto_id,
             description: description,
             fields: fields,
             name: collection_name # This duplicated field is kept for historical reasons.
@@ -25,41 +72,76 @@ module Milvus
       response.body.empty? ? true : response.body
     end
 
-    # Retrieve a Collection
-    def get(collection_name:)
-      response = client.connection.get(PATH) do |req|
+    # Describes the details of a collection.
+    #
+    # @param collection_name [String] The name of the collection to describe.
+    # @return [Hash] Server response
+    def describe(collection_name:)
+      response = client.connection.post("#{PATH}/describe") do |req|
         req.body = {
-          collection_name: collection_name
+          collectionName: collection_name
         }.to_json
       end
       response.body
     end
 
-    # Drop a Collection
-    def delete(collection_name:)
-      response = client.connection.delete(PATH) do |req|
+    # This operation lists all collections in the specified database.
+    #
+    # @return [Hash] Server response
+    def list
+      response = client.connection.post("#{PATH}/list") do |req|
+        req.body = {}
+      end
+      response.body
+    end
+
+    # This operation drops the current collection and all data within the collection.
+    #
+    # @param collection_name [String] The name of the collection to drop.
+    # @return [Hash] Server response
+    def drop(collection_name:)
+      response = client.connection.post("#{PATH}/drop") do |req|
         req.body = {
-          collection_name: collection_name
+          collectionName: collection_name
         }.to_json
       end
       response.body.empty? ? true : response.body
     end
 
     # Load the collection to memory before a search or a query
+    #
+    # @param collection_name [String] The name of the collection to load.
+    # @return [Hash] Server response
     def load(collection_name:)
       response = client.connection.post("#{PATH}/load") do |req|
         req.body = {
-          collection_name: collection_name
-        }.to_json
+          collectionName: collection_name
+        }
       end
       response.body.empty? ? true : response.body
     end
 
+    # This operation returns the load status of a specific collection.
+    #
+    # @param collection_name [String] The name of the collection to get the load status of.
+    # @return [Hash] Server response
+    def get_load_state(collection_name:)
+      response = client.connection.post("#{PATH}/get_load_state") do |req|
+        req.body = {
+          collectionName: collection_name
+        }
+      end
+      response.body
+    end
+
     # Release a collection from memory after a search or a query to reduce memory usage
+    #
+    # @param collection_name [String] The name of the collection to release.
+    # @return [Hash] Server response
     def release(collection_name:)
-      response = client.connection.delete("#{PATH}/load") do |req|
+      response = client.connection.post("#{PATH}/release") do |req|
         req.body = {
-          collection_name: collection_name
+          collectionName: collection_name
         }.to_json
       end
       response.body.empty? ? true : response.body

data/lib/milvus/entities.rb

@@ -4,59 +4,171 @@ module Milvus
   class Entities < Base
     PATH = "entities"
 
-    # Insert the data to the collection.
+    # This operation inserts data into a specific collection.
+    #
+    # @param collection_name [String] The name of the collection to insert data into.
+    # @param data [Array<Hash>] The data to insert.
+    # @param partition_name [String] The name of the partition to insert the data into.
+    #
+    # @return [Hash] The response from the server.
     def insert(
       collection_name:,
-      fields_data:,
-      num_rows:,
+      data:,
       partition_name: nil
     )
-      response = client.connection.post(PATH) do |req|
+      response = client.connection.post("#{PATH}/insert") do |req|
         req.body = {
-          collection_name: collection_name,
-          fields_data: fields_data,
-          num_rows: num_rows
-        }.to_json
+          collectionName: collection_name,
+          data: data
+        }
 
-        req.body["partition_name"] = partition_name if partition_name
+        req.body[:partitionName] = partition_name if partition_name
       end
       response.body.empty? ? true : response.body
     end
 
-    # Delete the entities with the boolean expression you created
+    # This operation deletes entities by their IDs or with a boolean expression.
+    #
+    # @param collection_name [String] The name of the collection to delete entities from.
+    # @param filter [String] The filter to use to delete entities.
+    # @return [Hash] The response from the server.
     def delete(
       collection_name:,
-      expression:
+      filter:
     )
-      response = client.connection.delete(PATH) do |req|
+      response = client.connection.post("#{PATH}/delete") do |req|
         req.body = {
-          collection_name: collection_name,
-          expr: expression
+          collectionName: collection_name,
+          filter: filter
         }.to_json
       end
       response.body.empty? ? true : response.body
     end
 
-    # Compact data manually
-    def compact!(
-      collection_id:
+    # This operation conducts a filtering on the scalar field with a specified boolean expression.
+    #
+    # @param collection_name [String] The name of the collection to query.
+    # @param filter [String] The filter to use to query the collection.
+    # @param output_fields [Array<String>] The fields to return in the results.
+    # @param limit [Integer] The maximum number of results to return.
+    def query(
+      collection_name:,
+      filter:,
+      output_fields: [],
+      limit: nil
     )
-      response = client.connection.post("compaction") do |req|
+      response = client.connection.post("#{PATH}/query") do |req|
         req.body = {
-          collectionID: collection_id
-        }.to_json
+          collectionName: collection_name,
+          filter: filter
+        }
+        req.body[:outputFields] = output_fields if output_fields
+        req.body[:limit] = limit if limit
       end
       response.body.empty? ? true : response.body
     end
 
-    # Check compaction status
-    def compact_status(
-      compaction_id:
+    # This operation inserts new records into the database or updates existing ones.
+    #
+    # @param collection_name [String] The name of the collection to upsert data into.
+    # @param data [Array<Hash>] The data to upsert.
+    # @param partition_name [String] The name of the partition to upsert the data into.
+    # @return [Hash] The response from the server.
+    def upsert(
+      collection_name:,
+      data:,
+      partition_name: nil
     )
-      response = client.connection.get("compaction/state") do |req|
+      response = client.connection.post("#{PATH}/upsert") do |req|
         req.body = {
-          compactionID: compaction_id
-        }.to_json
+          collectionName: collection_name,
+          data: data
+        }
+
+        req.body[:partitionName] = partition_name if partition_name
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation gets specific entities by their IDs
+    #
+    # @param collection_name [String] The name of the collection to get entities from.
+    # @param id [Array<Integer>] The IDs of the entities to get.
+    # @param output_fields [Array<String>] The fields to return in the results.
+    # @return [Hash] The response from the server.
+    def get(
+      collection_name:,
+      id:,
+      output_fields: nil
+    )
+      response = client.connection.post("#{PATH}/get") do |req|
+        req.body = {
+          collectionName: collection_name,
+          id: id
+        }
+        req.body[:outputFields] = output_fields if output_fields
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation conducts a vector similarity search with an optional scalar filtering expression.
+    #
+    # @param collection_name [String] The name of the collection to search.
+    # @param data [Array<Array<Float>>] The data to search for.
+    # @param anns_field [String] The field to search for.
+    # @param limit [Integer] The maximum number of results to return.
+    # @param output_fields [Array<String>] The fields to return in the results.
+    # @param offset [Integer] The offset to start from.
+    # @param filter [String] The filter to use to search the collection.
+    # @return [Hash] The search results.
+    def search(
+      collection_name:,
+      data:,
+      anns_field:,
+      limit: nil,
+      output_fields: [],
+      offset: nil,
+      filter: nil
+    )
+      response = client.connection.post("#{PATH}/search") do |req|
+        params = {
+          collectionName: collection_name,
+          data: data,
+          annsField: anns_field
+        }
+        params[:limit] = limit if limit
+        params[:outputFields] = output_fields if output_fields.any?
+        params[:offset] = offset if offset
+        params[:filter] = filter if filter
+        req.body = params
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # Executes a hybrid search.
+    #
+    # @param collection_name [String] The name of the collection to search.
+    # @param data [Array<Hash>] The data to search for.
+    # @param rerank [Hash] The rerank parameters.
+    # @param limit [Integer] The maximum number of results to return.
+    # @param output_fields [Array<String>] The fields to return in the results.
+    # @return [Hash] The search results.
+    def hybrid_search(
+      collection_name:,
+      search:,
+      rerank:,
+      limit: nil,
+      output_fields: []
+    )
+      response = client.connection.post("#{PATH}/hybrid_search") do |req|
+        params = {
+          collectionName: collection_name,
+          search: search,
+          rerank: rerank
+        }
+        params[:limit] = limit if limit
+        params[:outputFields] = output_fields if output_fields.any?
+        req.body = params
       end
       response.body.empty? ? true : response.body
     end

data/lib/milvus/indexes.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Milvus
+  class Indexes < Base
+    PATH = "indexes"
+
+    # This creates a named index for a target field, which can either be a vector field or a scalar field.
+    #
+    # @param collection_name [String] The name of the collection to create the index for.
+    # @param index_params [Hash] The parameters for the index.
+    # @return [Hash] Server response
+    def create(
+      collection_name:,
+      index_params:
+    )
+      response = client.connection.post("#{PATH}/create") do |req|
+        req.body = {
+          collectionName: collection_name,
+          indexParams: index_params
+        }.to_json
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation deletes index from a specified collection.
+    #
+    # @param collection_name [String] The name of the collection to delete the index from.
+    # @param index_name [String] The name of the index to delete.
+    # @return [Hash] Server response
+    def drop(
+      collection_name:,
+      index_name:
+    )
+      response = client.connection.post("#{PATH}/drop") do |req|
+        req.body = {
+          collectionName: collection_name,
+          indexName: index_name
+        }.to_json
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation describes the current index.
+    #
+    # @param collection_name [String] The name of the collection to describe the index for.
+    # @param index_name [String] The name of the index to describe.
+    # @return [Hash] Server response
+    def describe(
+      collection_name:,
+      index_name:
+    )
+      response = client.connection.post("#{PATH}/describe") do |req|
+        req.body = {
+          collectionName: collection_name,
+          indexName: index_name
+        }.to_json
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation lists all indexes of a specific collection.
+    #
+    # @param collection_name [String] The name of the collection to list indexes for.
+    # @return [Hash] Server response
+    def list(
+      collection_name:
+    )
+      response = client.connection.post("#{PATH}/list") do |req|
+        req.body = {
+          collectionName: collection_name
+        }.to_json
+      end
+      response.body.empty? ? true : response.body
+    end
+  end
+end

data/lib/milvus/partitions.rb

@@ -2,68 +2,104 @@
 
 module Milvus
   class Partitions < Base
-    PATH = "partition"
+    PATH = "partitions"
 
-    # Create a partition
+    # This operation lists all partitions in the database used in the current connection.
+    #
+    # @param collection_name [String] The name of the collection.
+    # @return [Hash] Server response
+    def list(collection_name:)
+      response = client.connection.post("#{PATH}/list") do |req|
+        req.body = {collectionName: collection_name}
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation creates a partition in a collection.
+    #
+    # @param collection_name [String] The name of the collection to create the partition in.
+    # @param partition_name [String] The name of the partition to create.
     def create(collection_name:, partition_name:)
-      response = client.connection.post(PATH) do |req|
+      response = client.connection.post("#{PATH}/create") do |req|
+        req.body = {
+          collectionName: collection_name,
+          partitionName: partition_name
+        }
+      end
+      response.body.empty? ? true : response.body
+    end
+
+    # This operation drops the current partition. To successfully drop a partition, ensure that the partition is already released.
+    #
+    # @param collection_name [String] The name of the collection to drop the partition from.
+    # @param partition_name [String] The name of the partition to drop.
+    # @return [Hash] Server response
+    def drop(collection_name:, partition_name:)
+      response = client.connection.post("#{PATH}/drop") do |req|
         req.body = {
-          collection_name: collection_name,
-          partition_name: partition_name
+          collectionName: collection_name,
+          partitionName: partition_name
         }
       end
       response.body.empty? ? true : response.body
     end
 
-    # Verify if a partition exists
-    def get(collection_name:, partition_name:)
-      response = client.connection.get("#{PATH}/existence") do |req|
+    # This operation checks whether a partition exists.
+    #
+    # @param collection_name [String] The name of the collection to check for the partition in.
+    # @param partition_name [String] The name of the partition to check.
+    # @return [Hash] Server response
+    def has(collection_name:, partition_name:)
+      response = client.connection.post("#{PATH}/has") do |req|
         req.body = {
-          collection_name: collection_name,
-          partition_name: partition_name
+          collectionName: collection_name,
+          partitionName: partition_name
         }
       end
       response.body.empty? ? true : response.body
     end
 
-    # Dropping a partition
-    def delete(collection_name:, partition_name:)
-      response = client.connection.delete(PATH) do |req|
+    # This operation loads the data of the current partition into memory.
+    #
+    # @param collection_name [String] The name of the collection to load.
+    # @param partition_names [Array<String>] The names of the partitions to load.
+    # @return [Hash] Server response
+    def load(collection_name:, partition_names:)
+      response = client.connection.post("#{PATH}/load") do |req|
         req.body = {
-          collection_name: collection_name,
-          partition_name: partition_name
+          collectionName: collection_name,
+          partitionNames: partition_names
         }
       end
       response.body.empty? ? true : response.body
     end
 
-    # Load a Partition
-    def load(
-      collection_name:,
-      partition_names:,
-      replica_number: nil
-    )
-      response = client.connection.post("#{PATH}s/load") do |req|
+    # This operation releases the data of the current partition from memory.
+    #
+    # @param collection_name [String] The name of the collection to release.
+    # @param partition_name [String] The name of the partition to release.
+    # @return [Hash] Server response
+    def release(collection_name:, partition_names:)
+      response = client.connection.post("#{PATH}/release") do |req|
         req.body = {
-          collection_name: collection_name,
-          partition_names: partition_names
+          collectionName: collection_name,
+          partitionNames: partition_names
         }
-        req.body[:replica_number] = replica_number if replica_number
       end
       response.body.empty? ? true : response.body
     end
 
-    def release(
-      collection_name:,
-      partition_names:,
-      replica_number: nil
-    )
-      response = client.connection.delete("#{PATH}s/load") do |req|
+    # This operations gets the number of entities in a partition.
+    #
+    # @param collection_name [String] The name of the collection to get the number of entities in.
+    # @param partition_name [String] The name of the partition to get the number of entities in.
+    # @return [Hash] Server response
+    def get_stats(collection_name:, partition_name:)
+      response = client.connection.post("#{PATH}/get_stats") do |req|
         req.body = {
-          collection_name: collection_name,
-          partition_names: partition_names
+          collectionName: collection_name,
+          partitionName: partition_name
         }
-        req.body[:replica_number] = replica_number if replica_number
       end
       response.body.empty? ? true : response.body
     end

data/lib/milvus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Milvus
-  VERSION = "0.9.3"
+  VERSION = "0.10.0"
 end

data/lib/milvus.rb

@@ -9,9 +9,6 @@ module Milvus
   autoload :Client, "milvus/client"
   autoload :Error, "milvus/error"
   autoload :Entities, "milvus/entities"
-  autoload :Health, "milvus/health"
-  autoload :Indices, "milvus/indices"
+  autoload :Indexes, "milvus/indexes"
   autoload :Partitions, "milvus/partitions"
-  autoload :Search, "milvus/search"
-  autoload :Query, "milvus/query"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: milvus
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.10.0
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry-byebug
@@ -51,6 +51,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".env.example"
 - ".rspec"
 - ".tool-versions"
 - CHANGELOG.md
@@ -66,11 +67,8 @@ files:
 - lib/milvus/constants.rb
 - lib/milvus/entities.rb
 - lib/milvus/error.rb
-- lib/milvus/health.rb
-- lib/milvus/indices.rb
+- lib/milvus/indexes.rb
 - lib/milvus/partitions.rb
-- lib/milvus/query.rb
-- lib/milvus/search.rb
 - lib/milvus/version.rb
 - sig/milvus.rbs
 homepage: https://github.com/andreibondarev/milvus

data/lib/milvus/health.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Milvus
-  class Health < Base
-    PATH = "health"
-
-    def get
-      response = client.connection.get(PATH.to_s)
-      response.body
-    end
-  end
-end

data/lib/milvus/indices.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Milvus
-  class Indices < Base
-    PATH = "index"
-
-    def create(
-      collection_name:,
-      field_name:,
-      extra_params:
-    )
-      response = client.connection.post(PATH) do |req|
-        req.body = {
-          collection_name: collection_name,
-          field_name: field_name,
-          extra_params: extra_params
-        }.to_json
-      end
-      response.body.empty? ? true : response.body
-    end
-
-    def delete(
-      collection_name:,
-      field_name:
-    )
-      response = client.connection.delete(PATH) do |req|
-        req.body = {
-          collection_name: collection_name,
-          field_name: field_name
-        }.to_json
-      end
-      response.body.empty? ? true : response.body
-    end
-  end
-end

data/lib/milvus/query.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Milvus
-  class Query < Base
-    PATH = "query"
-
-    def post(
-      collection_name:,
-      output_fields:,
-      expr:
-    )
-      response = client.connection.post(PATH) do |req|
-        req.body = {
-          collection_name: collection_name,
-          expr: expr
-        }
-        if output_fields
-          req.body[:output_fields] = output_fields
-        end
-      end
-      response.body.empty? ? true : response.body
-    end
-  end
-end

data/lib/milvus/search.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Milvus
-  class Search < Base
-    PATH = "search"
-
-    def post(
-      collection_name:,
-      anns_field:,
-      top_k:,
-      params:,
-      metric_type:,
-      vectors:,
-      dsl_type:,
-      output_fields: nil,
-      round_decimal: nil,
-      vector_type: nil
-    )
-      response = client.connection.post(PATH) do |req|
-        req.body = {
-          collection_name: collection_name,
-          search_params: [
-            {key: "anns_field", value: anns_field},
-            {key: "topk", value: top_k},
-            {key: "params", value: params},
-            {key: "metric_type", value: metric_type}
-          ],
-          dsl_type: dsl_type,
-          vectors: vectors,
-          vector_type: vector_type
-        }
-        if round_decimal
-          req.body[:search_params].push(
-            {key: "round_decimal", value: round_decimal}
-          )
-        end
-        if output_fields
-          req.body[:output_fields] = output_fields
-        end
-      end
-      response.body.empty? ? true : response.body
-    end
-  end
-end