Have ideas to improve npm?Join in the discussion! »

    @arkie-ai/milvus-client
    TypeScript icon, indicating that this package has built-in type declarations

    1.0.0 • Public • Published

    Milvus Node SDK

    This repository is a node client for milvus service. It uses gRPC to communicate with milvus server with protobuf which is a mechanism for serializing structured data.

    Getting started

    Assuming you are already familiar with milvus, this repository provides the some interfaces that you can use to communicate with the server of milvus.

    Prerequisites

    Before you start to use this package, it is recommended that you learn something about gRPC and Milvus so that you can figure out how the flow works.

    Installation

    Install the milvus node sdk package

    npm install @arkie/milvus-client

    Interface

    There are some important interfaces that you need to know.

    Status

    Because it's a communication between client and server, every response comes from server will indicate that if the server is down or the operation is successful or not.

    interface Status {
        error_code: string      // error code
        reason: string          // the reason why error happens, would be empty if there are no errors
    }

    Error Code

    There are some error codes that indicates the error briefly. If the operation is failed, the status will carry error_code and reason to tell the user why this operation fails.

    enum ErrorCode {
        SUCCESS = 0; // success operation
        UNEXPECTED_ERROR = 1;
        CONNECT_FAILED = 2;
        PERMISSION_DENIED = 3;
        TABLE_NOT_EXISTS = 4;
        ILLEGAL_ARGUMENT = 5;
        ILLEGAL_RANGE = 6;
        ILLEGAL_DIMENSION = 7;
        ILLEGAL_INDEX_TYPE = 8;
        ILLEGAL_TABLE_NAME = 9;
        ILLEGAL_TOPK = 10;
        ILLEGAL_ROWRECORD = 11;
        ILLEGAL_VECTOR_ID = 12;
        ILLEGAL_SEARCH_RESULT = 13;
        FILE_NOT_FOUND = 14;
        META_FAILED = 15;
        CACHE_FAILED = 16;
        CANNOT_CREATE_FOLDER = 17;
        CANNOT_CREATE_FILE = 18;
        CANNOT_DELETE_FOLDER = 19;
        CANNOT_DELETE_FILE = 20;
        BUILD_INDEX_ERROR = 21;
        ILLEGAL_NLIST = 22;
        ILLEGAL_METRIC_TYPE = 23;
        OUT_OF_MEMORY = 24;
    }

    How to use

    Notice that every function is async except clientVersion.

    // import the package
    // init the client with host and port
    const Milvus = require('milvus-client')
    const client = new Milvus.MilvusClient('localhost', 9000)

    clientVersion

    You can get the version of the client which is "0.6.0" for now.

    Note: it's not the package version, but the client version.

    const clientVersion = client.clientVersion()

    serverStatus

    Use this function to get the status of the server to see if the server is running or not.

    // response would be look like this
    // {
    //     status: {
    //         error_code: 'SUCCESS',
    //         reason: ''
    //     },
    //     string_reply: 'OK'
    // }
    const serverStatus = await client.serverStatus()

    serverVersion

    Use this function to get the version of the server.

    // response would be look like this
    // {
    //     status: {
    //         error_code: 'SUCCESS',
    //         reason: ''
    //     },
    //     string_reply: '0.6.0'
    // }
    const serverVersion = await client.serverVersion()

    serverMode

    Use this function to see if the server is running with CPU or GPU.

    // response would be look like this
    // {
    //     status: {
    //         error_code: 'SUCCESS',
    //         reason: ''
    //     },
    //     string_reply: 'CPU'
    // }
    const serverMode = await client.serverMode()

    createTable

    Create a table in milvus named 'testTable' whose vector's dimension is 5 and indexFileSize is 1GB and metric_type is L2 (L2 or IP).

    // response: Status
    // { error_code: 'SUCCESS', reason: '' }
    const createTableResponse = await client.createTable({
        table_name: 'testTable', // table's name
        dimension: 5,          // dimension of table's vector
        index_file_size: 1,      // must be a positive value
        metric_type: 1,   // L2 = 1, IP = 2
    })

    showTables

    Show all tables in milvus server

    // response
    // { status: Status, table_names: string[] }
    const tables = await client.showTables()

    dropTable

    Drop a table

    // response
    // { error_code: 'SUCCESS', reason: '' }
    const dropResponse = await client.dropTable('testTable')

    hasTable

    Check out if there is a table by the name of 'testTable' in the server

    // response
    // { error_code: 'SUCCESS', reason: '' }
    const hasTable = await client.hasTable('testTable')

    countTable

    Get table row count

    /**
     * @brief Get table row count
     *
     * This method is used to get table row count.
     *
     * @param table_name, target table's name.
     * @return Indicate if this operation is successful and row_count
     * 
     * response example:
     * { status: Status, table_row_count: number }
     */
    const rowCountResponse = await client.countTable('testTable')
     

    describeTable

    Describe information about a table

    // response
    // {
    //   status: Status,
    //   table_name: string,
    //   dimension: number,
    //   index_file_size: number,
    //   metric_type: number
    // }
    //
    // 
    const tableInformation = await client.describeTable('testTable')

    createIndex

    Create index in a table

    Note: there is a default index method called 'idmap'

    /**
     * @brief Create index method
     *
     * This method is used to create index for whole table(and its partitions).
     *
     *  @table_name: table name is going to be create index.
     *  @index_type: 0-invalid, 1-idmap, 2-ivflat, 3-ivfsq8, 4-nsgmix
     *  @nlist: index nlist
     *
     * @return Status Indicate if build index successfully.
     */
    const createIndexResponse = await client.createIndex({
      table_name: 'testTable',
      index: {
        index_type: 2,
        nlist: 5,
      }
    })

    describeIndex

    Describe the index of a table

    // response
    interface Index {
      index_type: number
      nlist: number
    }
    // { table_name: string, status: Status, index: Index, index_name: string}
    const indexDescription = await client.describeIndex('testTable')

    dropIndex

    Drop the index of the table except default index idmap

    // response
    // { error_code: 'SUCCESS', reason: '' }
    const dropIndexResponse = await client.dropIndex('testTable')

    insert

    Insert some vectors into a table

    /**
     * @brief Insert vector to table
     *
     * This method is used to insert vector array to table.
     *
     * @param table_name, target table's name.
     * @param partition_tag, target partition's tag, keep empty if no partition.
     * @param row_record_array, vector array is inserted.
     * @param row_id_array, optional
     *  specify id for each vector,
     *  if this array is empty, milvus will generate unique id for each vector,
     *  and return all ids by this parameter.
     *
     * @return Indicate if vector array are inserted successfully
     *  and if the operation is successful, then the ids of vectors will be returned too
     *
     * resposne example:
     * {
     *   status: { error_code: 'SUCCESS', reason: '' },
     *   vector_id_array: [ 123891238129, 2543534523 ] // if two vectors are inserted
     * }
     */
     
    const insertResponse = await client.insert({
        table_name: 'testTable',
        partition_tag: '',
        row_record_array: [{
            vector_data: [1, 2, 3, 4, 5],
        }, {
            vector_data: [5, 4, 3, 2, 1],
        }]
    })

    search

    Query similar vectors in the table 'testTable'

    /**
     * @brief Search vector
     *
     * This method is used to query vector in table.
     *
     * @param table_name, target table's name.
     * @param partition_tag_array, target partitions, keep empty if no partition.
     * @param query_record_array, all vector are going to be queried.
     * @param query_range_array, [deprecated] time ranges, if not specified, will search in whole table
     * @param topk, how many similarity vectors will be searched.
     * @param nprobe, the number of centroids choose to search.
     *
     * @return Indicate if query is successful and vectors' id will be returned
     *
     * response example:
     * {
     *   status: { error_code: 'SUCCESS', reason: '' },
     *   ids: [ 12839129314, 2384572385 ],
     *   distances: [ 123.54, 1234.54 ],
     *   row_num: 1
     * }
     */
    const searchResponse = await client.search({
        table_name: 'testTable',
        query_record_array: [{
            vector_data: [1, 2, 3, 4, 5],
        }],
        topk: 2,
        nprobe: 2,
        partition_tag_array: [],
        query_range_array: [],
    })
     

    deleteByDate

    Delete data between two date

    /*
     * @table_name: table's name
     * @range: date range, use 'YYYY-MM-DD' format
     *
     * @response Status
     * { error_code: 'SUCCESS', reason: '' }
     */
    const deleteResponse = await client.deleteByDate({
        table_name: 'testTable',
        range: {
            start_value: '2020-01-01',
            end_value: '2020-02-01'
        }
    })

    preloadTable

    This method is used to preload the table so that you can insert and search quickly.

    // response
    // { error_code: 'SUCCESS', reason: '' }
    const preloadResponse = await client.preloadTable('testTable')

    createPartition

    Create a partition for a table so that you can search in some partitions lately.

    // response
    // { error_code: 'SUCCESS', reason: '' }
    // @param type PartitionParam
    interface PartitionParam {
        table_name: string
        partition_name: string
        tag: string
    }
    const createPartitionResponse = await client.createPartition({
        table_name: 'testTable',
        partition_name: 'partition1',
        tag: 'tag1',
    })

    showPartitions

    Show all partitions in a table

    // response
    // { status: Status, partition_array: PartitionParam[] }
    const partitions = await client.showPartitions('testTable')

    dropPartition

    Drop the partition that you don't want any more in a table

    // response
    // { error_code: 'SUCCESS', reason: '' }
    const dropPartitionResponse = await client.dropPartition({
        table_name: 'testTable',
        partition_name: 'partition1',
        tag: 'tag1'
    })

    cmd

    You can go to milvus web site to see if there are some command that you can send to the server such as 'get_config', 'mode', 'status'...

    // parameter is a string ---- command
    // response
    // { status: Status, stringReply: string }
    const cmdResponse = await client.cmd('version')

    Version

    The SDK corresponds to version 0.6.0 of the service.

    Keywords

    Milvus gRPC ProtoBuf Typescript Vector Search

    License

    Keywords

    none

    Install

    npm i @arkie-ai/milvus-client

    DownloadsWeekly Downloads

    1

    Version

    1.0.0

    License

    ISC

    Unpacked Size

    49 kB

    Total Files

    16

    Last publish

    Collaborators

    • avatar
    • avatar