Milvus Node.js SDK

https://github.com/milvus-io/milvus-sdk-node
Admin
Official Node.js SDK for Milvus vector database providing gRPC and HTTP clients for vector...
Tokens:176,781
Snippets:1,858
Trust Score:9.9
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### End-to-End Example: Full Collection Scan with Query Iterator

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/operations/iterators.mdx

Demonstrates creating a collection, inserting data, and then scanning all entities matching a specific category using `queryIterator`. This example includes setup, data insertion, iteration, and cleanup.

```javascript
import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({ address: 'localhost:19530' });

// Create and populate a collection
await client.createCollection({
  collection_name: 'iterator_demo',
  fields: [
    { name: 'id', data_type: DataType.Int64, is_primary_key: true, autoID: true },
    { name: 'category', data_type: DataType.VarChar, max_length: 64 },
    { name: 'vector', data_type: DataType.FloatVector, dim: 4 },
  ],
});

await client.createIndex({
  collection_name: 'iterator_demo',
  field_name: 'vector',
  index_type: 'AUTOINDEX',
  metric_type: 'COSINE',
});

await client.loadCollectionSync({ collection_name: 'iterator_demo' });

// Insert sample data
const data = Array.from({ length: 1000 }, (_, i) => ({
  category: `cat_${i % 10}`,
  vector: Array.from({ length: 4 }, () => Math.random()),
}));
await client.insert({ collection_name: 'iterator_demo', data });

// Scan all entities in category 'cat_5'
let totalCount = 0;
const iterator = await client.queryIterator({
  collection_name: 'iterator_demo',
  expr: 'category == "cat_5"',
  output_fields: ['id', 'category'],
  batchSize: 50,
});

for await (const batch of iterator) {
  totalCount += batch.length;
  console.log(`Fetched ${batch.length} items, total: ${totalCount}`);
}

console.log(`Total matching entities: ${totalCount}`);

// Cleanup
await client.dropCollection({ collection_name: 'iterator_demo' });
```

--------------------------------

### Complete Example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/operations/data-operations-delete.mdx

Complete example showing deletion, flush, and verification.

```javascript
import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530',
});

await client.connectPromise;

// Delete by IDs
const deleteResult = await client.delete({
  collection_name: 'my_collection',
  ids: [1, 2, 3],
});

console.log('Deleted:', deleteResult.delete_cnt);

// Delete by filter
await client.delete({
  collection_name: 'my_collection',
  expr: 'age < 18',
});

// Flush to persist
await client.flush({
  collection_names: ['my_collection'],
});

// Verify deletion
const count = await client.count({
  collection_name: 'my_collection',
});
```

--------------------------------

### Install Dependencies

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/examples/LangChain/README.md

Install the LangChain and Milvus SDK packages.

```shell
npm install langchain @zilliz/milvus2-sdk-node
```

--------------------------------

### Install Milvus SDK Node

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/examples/milvus/README.md

Run this command to install the Milvus SDK Node and its dependencies.

```shell
npm install
```

--------------------------------

### Complete Example with MilvusClient

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/operations/data-operations-query.mdx

Complete example showing connection, loading a collection, querying with a filter expression, and searching with a random 128-dimensional vector. Uses `nprobe: 64` for search parameters and outputs fields `id`, `text`, `age`.

```javascript
import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530',
});

await client.connectPromise;

// Load collection
await client.loadCollectionSync({
  collection_name: 'my_collection',
});

// Query
const queryResults = await client.query({
  collection_name: 'my_collection',
  expr: 'age > 25',
  output_fields: ['id', 'text', 'age'],
  limit: 10,
});

console.log('Query results:', queryResults.data);

// Search
const searchResults = await client.search({
  collection_name: 'my_collection',
  data: [Array.from({ length: 128 }, () => Math.random())],
  expr: 'age > 25',
  limit: 10,
  output_fields: ['id', 'text', 'age'],
  params: {
    nprobe: 64,
  },
});

console.log('Search results:', searchResults.results);
```

--------------------------------

### Schema and index createCollection example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/client.mdx

Creates a collection with explicit field definitions and index parameters, used for more detailed collection setup.

```typescript
await client.createCollection({
  collection_name: 'books',
  fields: [
    { name: 'id', data_type: DataType.Int64, is_primary_key: true },
    { name: 'embedding', data_type: DataType.FloatVector, dim: 768 },
  ],
  index_params: {
    field_name: 'embedding',
    index_type: 'AUTOINDEX',
    metric_type: 'COSINE',
  },
});

```

--------------------------------

### Install and run documentation site

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/reference/contributing.mdx

Install documentation dependencies and run the documentation site locally. Use this when contributing to the docs. Requires Node.js 22.12.0 or newer.

```bash
yarn --cwd docs install --frozen-lockfile
npm run doc
npm run doc:dev
```

--------------------------------

### Run Milvus SDK Node Example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/examples/milvus/README.md

Execute TypeScript example files directly using ts-node. Replace <example_file_name>.ts with the actual file name.

```shell
ts-node <example_file_name>.ts
```

--------------------------------

### Complete Example: Create Collection and Insert Data

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/operations/data-operations-insert.mdx

This comprehensive example demonstrates initializing the Milvus client, connecting, creating a collection with defined fields, inserting data, and flushing the collection to ensure persistence. It includes necessary imports from '@zilliz/milvus2-sdk-node'.

```javascript
import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530',
});

await client.connectPromise;

// Create collection
await client.createCollection({
  collection_name: 'my_collection',
  fields: [
    {
      name: 'id',
      data_type: DataType.Int64,
      is_primary_key: true,
      autoID: true,
    },
    {
      name: 'vector',
      data_type: DataType.FloatVector,
      dim: 128,
    },
    {
      name: 'text',
      data_type: DataType.VarChar,
      max_length: 256,
    },
  ],
});

// Insert data
const result = await client.insert({
  collection_name: 'my_collection',
  data: [
    {
      vector: Array.from({ length: 128 }, () => Math.random()),
      text: 'First document',
    },
    {
      vector: Array.from({ length: 128 }, () => Math.random()),
      text: 'Second document',
    },
  ],
});

console.log('Inserted IDs:', result.IDs);

// Flush to ensure data is persisted
await client.flush({
  collection_names: ['my_collection'],
});
```

--------------------------------

### Install Milvus SDK with npm or yarn

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/advanced/vercel.mdx

Install the @zilliz/milvus2-sdk-node package using npm or yarn.

```bash
npm install @zilliz/milvus2-sdk-node
# or
yarn add @zilliz/milvus2-sdk-node
```

--------------------------------

### Deploy with Serverless commands

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/advanced/aws-lambda.mdx

Installs the Serverless Framework globally and deploys the service.

```bash
# Install Serverless Framework
npm install -g serverless

# Deploy
serverless deploy

```

--------------------------------

### Install Dependencies

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/CLAUDE.md

Installs project dependencies using yarn.

```bash
yarn install
```

--------------------------------

### Create Search Route with Next.js App Router

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/advanced/vercel.mdx

Setup an App Router API route for performing a vector search. This example shows how to initialize a singleton HttpClient using environment variables and handle a POST request with validation and error handling.

```javascript
import { HttpClient } from '@zilliz/milvus2-sdk-node';
import { NextResponse } from 'next/server';

let client;

function getClient() {
  if (!client) {
    client = new HttpClient({
      baseURL: process.env.MILVUS_ENDPOINT,
      token: process.env.MILVUS_TOKEN,
      timeout: 10000,
    });
  }
  return client;
}

export async function POST(request) {
  try {
    const body = await request.json();
    const { collectionName, vector, limit = 10, outputFields = [] } = body;

    if (!collectionName || !vector) {
      return NextResponse.json(
        { error: 'Missing required fields: collectionName and vector' },
        { status: 400 }
      );
    }

    const milvusClient = getClient();

    const results = await milvusClient.search({
      collectionName,
      data: Array.isArray(vector[0]) ? vector : [vector],
      limit,
      outputFields,
    });

    return NextResponse.json({ results });
  } catch (error) {
    console.error('Milvus error:', error);
    return NextResponse.json(
      { error: error.message, status: error.status || 500 },
      { status: error.status || 500 }
    );
  }
}
```

--------------------------------

### Run Development Server

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/examples/nextjs/README.md

Start the Next.js development server to view the application locally.

```bash
yarn dev
```

--------------------------------

### listResourceGroups usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example of listing resource groups and logging the resource group names.

```typescript
const groups = await client.listResourceGroups();
console.log(groups.resource_groups);
```

--------------------------------

### updateReplicateConfiguration usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example of updating replication configuration with primary and secondary clusters and a topology entry.

```typescript
await client.updateReplicateConfiguration({
  clusters: [
    {
      cluster_id: 'primary',
      connection_param: {
        uri: 'primary.example.com:19530',
        token: process.env.PRIMARY_TOKEN,
      },
    },
    {
      cluster_id: 'secondary',
      connection_param: {
        uri: 'secondary.example.com:19530',
        token: process.env.SECONDARY_TOKEN,
      },
    },
  ],
  cross_cluster_topology: [
    {
      source_cluster_id: 'primary',
      target_cluster_id: 'secondary',
    },
  ],
});
```

--------------------------------

### Example: getReplicateConfiguration usage

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Calls getReplicateConfiguration on the client and logs the clusters from the returned configuration.

```typescript
const config = await client.getReplicateConfiguration();
console.log(config.configuration.clusters);
```

--------------------------------

### MilvusClient constructor (Local Milvus username/password)

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/client.mdx

Authentication example for local Milvus using username and password.

```APIDOC
## MilvusClient constructor (Local Milvus username/password)

### Description
Creates a MilvusClient instance using local Milvus credentials.

### Method
constructor

### Parameters
- **options** (object) - Required - Client configuration.
  - **address** (string) - Required - Milvus server address (e.g., 'localhost:19530').
  - **username** (string) - Required - Username for authentication.
  - **password** (string) - Required - Password for authentication.

### Request Example
```typescript
const client = new MilvusClient({
  address: 'localhost:19530',
  username: 'root',
  password: 'Milvus',
});
```
```

--------------------------------

### query example with filter and ordering

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example query that filters by category, selects output fields, limits results, and orders by id ascending.

```typescript
const res = await client.query({
  collection_name: 'books',
  filter: 'category == "database"',
  output_fields: ['id', 'title', 'category'],
  limit: 10,
  order_by_fields: 'id:asc',
});
```

--------------------------------

### Install versioned SDK for Milvus compatibility

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/README.md

Install a specific SDK version to match a Milvus server version. Use @3 for Milvus v3.0.0+, @2.6 for v2.6.0+, @2.5.12 for v2.5.0+, and @2.4.9 for v2.4.0+.

```bash
yarn add @zilliz/milvus2-sdk-node@3
```

```bash
yarn add @zilliz/milvus2-sdk-node@2.6
```

```bash
yarn add @zilliz/milvus2-sdk-node@2.5.12
```

```bash
yarn add @zilliz/milvus2-sdk-node@2.4.9
```

--------------------------------

### compactCollection(data, options?)

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/http-client.mdx

Starts collection compaction.

```APIDOC
## compactCollection(data, options?)

### Description
Starts collection compaction.

### Method
SDK Method

### Parameters
- **data** (object) - Required - Data for starting compaction.
- **options** (object) - Optional - Additional options.

### Request Example
```typescript
const compaction = await client.compactCollection({
  collectionName: 'books',
});
```

```

--------------------------------

### getVersion usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/system.mdx

Calls getVersion and logs the version.

```typescript
const version = await client.getVersion();
console.log(version.version);
```

--------------------------------

### listFileResources usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/system.mdx

Lists file resources and logs their id, name, and path.

```typescript
const result = await client.listFileResources();
for (const resource of result.resources) {
  console.log(resource.id, resource.name, resource.path);
}
```

--------------------------------

### MilvusClient constructor (Zilliz Cloud token)

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/client.mdx

Authentication example for Zilliz Cloud using a token.

```APIDOC
## MilvusClient constructor (Zilliz Cloud token)

### Description
Creates a MilvusClient instance using a Zilliz Cloud API token.

### Method
constructor

### Parameters
- **options** (object) - Required - Client configuration.
  - **address** (string) - Required - Cluster endpoint address.
  - **ssl** (boolean) - Required - Enable SSL/TLS.
  - **token** (string) - Required - Zilliz Cloud API key.

### Request Example
```typescript
const client = new MilvusClient({
  address: 'your-cluster-endpoint:19530',
  ssl: true,
  token: process.env.ZILLIZ_CLOUD_API_KEY,
});
```
```

--------------------------------

### Initialize Project Directory

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/examples/LangChain/README.md

Create and enter a new directory for the project.

```shell
mkdir langchain-milvus
cd langchain-milvus
```

--------------------------------

### Manage Databases and Create Collections

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/getting-started/examples-tutorials.mdx

Demonstrates creating a new database, instantiating a client for that specific database, and creating a collection within it. Also shows how to list all available databases.

```javascript
// Create database
await client.createDatabase({
  db_name: 'production_db',
});

// Create client for specific database
const prodClient = new MilvusClient({
  address: 'localhost:19530',
  database: 'production_db',
});

// Create collection in production database
await prodClient.createCollection({
  collection_name: 'prod_collection',
  fields: [/* ... */],
});

// List databases
const databases = await client.listDatabases();
console.log('Databases:', databases.db_names);
```

--------------------------------

### Build

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/reference/contributing.mdx

Build the project.

```bash
yarn build
```

--------------------------------

### Flush, get load state, and compact a collection

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/http-client.mdx

Flushes the 'books' collection, then retrieves its load state, and finally starts compaction. Use when you need to ensure data is persisted before checking load status or triggering compaction.

```typescript
await client.flushCollection({ collectionName: 'books' });

const loadState = await client.getCollectionLoadState({
  collectionName: 'books',
});

const compaction = await client.compactCollection({
  collectionName: 'books',
});
```

--------------------------------

### Test locally with wrangler dev and curl

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/advanced/cloudflare.mdx

Start the local development server with `wrangler dev` and test the Worker endpoint using a curl POST request. The example sends a JSON payload with a collection name, vector, and limit to the `/api/search` route.

```bash
# Start local development server
wrangler dev

# Test with curl
curl -X POST http://localhost:8787/api/search \
  -H "Content-Type: application/json" \
  -d '{
    "collectionName": "my_collection",
    "vector": [0.1, 0.2, 0.3],
    "limit": 5
  }'
```

--------------------------------

### Bulk Data Import with BulkWriter and bulkInsert

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/llms.txt

Generates Milvus-compatible JSON or Parquet files locally with BulkWriter, then imports them server-side via bulkInsert. Use for bulk data import. The example shows creating a writer with a schema, appending rows, closing to get batch files, and checking import state.

```typescript
import { BulkWriter, DataType } from '@zilliz/milvus2-sdk-node';

const writer = new BulkWriter({
  schema: {
    fields: [
      { name: 'id', data_type: DataType.Int64, is_primary_key: true },
      { name: 'vector', data_type: DataType.FloatVector, dim: 128 },
    ],
  },
  format: 'parquet', // or 'json'
  localPath: './bulk_data',
});

for (const row of largeDataset) {
  await writer.append(row);
}

const batchFiles = await writer.close();

const task = await client.bulkInsert({
  collection_name: 'my_collection',
  files: ['data.parquet'],
});

await client.getImportState({ taskId: task.task_id });
```

--------------------------------

### Complete configuration example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/core-concepts/client-configuration.mdx

Shows all available configuration options for MilvusClient, including authentication, TLS, timeouts, retries, database, logging, and connection pooling.

```javascript
const client = new MilvusClient({
  // Required
  address: 'localhost:19530',

  // Authentication (choose one)
  username: 'root',
  password: 'Milvus',
  // OR
  token: 'api-key',

  // SSL/TLS
  ssl: true,
  tls: {
    rootCertPath: '/path/to/ca.pem',
    serverName: 'milvus.example.com',
  },

  // Timeouts and retries
  timeout: 30000,
  maxRetries: 3,
  retryDelay: 1000,

  // Database
  database: 'default',

  // Logging
  logLevel: 'info',
  logPrefix: 'milvus',

  // Connection pooling
  pool: {
    min: 2,
    max: 10,
  },
});
```

--------------------------------

### transferReplica Example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example usage of transferReplica.

```typescript
await client.transferReplica({
  collection_name: 'books',
  source_resource_group: 'rg_default',
  target_resource_group: 'rg_search',
  num_replica: 1,
});
```

--------------------------------

### transferNode Example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example usage of transferNode.

```typescript
await client.transferNode({
  source_resource_group: 'rg_default',
  target_resource_group: 'rg_search',
  num_node: 1,
});
```

--------------------------------

### updateResourceGroups Example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example usage of updateResourceGroups.

```typescript
await client.updateResourceGroups({
  resource_groups: {
    rg_search: {
      requests: { node_num: 2 },
      limits: { node_num: 4 },
    },
  },
});
```

--------------------------------

### Initialize Node.js Project

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/examples/LangChain/README.md

Initialize a new Node.js project with default settings.

```shell
npm init -y
```

--------------------------------

### Minimal RBAC Setup Flow

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/users-roles.mdx

Demonstrates the minimal steps to set up RBAC by creating a user, a role, assigning the user to the role, and granting a scoped privilege.

```typescript
await client.createUser({
  username: 'readonly_user',
  password: 'strong-password',
});

await client.createRole({ roleName: 'readonly_role' });
await client.addUserToRole({
  username: 'readonly_user',
  roleName: 'readonly_role',
});

await client.grantPrivilegeV2({
  role: 'readonly_role',
  privilege: CollectionPrivileges.Search,
  db_name: 'default',
  collection_name: 'book_embeddings',
});
```

--------------------------------

### Hybrid search example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of performing a hybrid search using the client.

```typescript
const res = await client.hybridSearch({
  collection_name: 'books',
  data: [
    {
      anns_field: 'dense_embedding',
      data: [0.1, 0.2, 0.3, 0.4],
      params: { ef: 64 },
    },
    {
      anns_field: 'sparse_embedding',
      data: { 10: 0.8, 42: 0.3 },
    },
  ],
  rerank: { strategy: 'rrf', params: { k: 60 } },
  limit: 10,
  output_fields: ['title'],
});
```

--------------------------------

### dropResourceGroup usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example of dropping a resource group named 'rg_search'.

```typescript
await client.dropResourceGroup({ resource_group: 'rg_search' });
```

--------------------------------

### describeResourceGroup usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example of describing a resource group named 'rg_search'.

```typescript
const group = await client.describeResourceGroup({
  resource_group: 'rg_search',
});
```

--------------------------------

### Complete CRUD Operations Example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/getting-started/examples-tutorials.mdx

Demonstrates creating a collection, inserting data, creating an index, loading the collection, performing search and query operations, deleting data, and dropping the collection.

```javascript
import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530',
});

await client.connectPromise;

// Create collection
const schema = [
  {
    name: 'id',
    data_type: DataType.Int64,
    is_primary_key: true,
    autoID: true,
  },
  {
    name: 'vector',
    data_type: DataType.FloatVector,
    dim: 128,
  },
  {
    name: 'text',
    data_type: DataType.VarChar,
    max_length: 256,
  },
];

await client.createCollection({
  collection_name: 'my_collection',
  fields: schema,
});

// Insert data
const insertResult = await client.insert({
  collection_name: 'my_collection',
  data: [
    {
      vector: Array.from({ length: 128 }, () => Math.random()),
      text: 'Hello Milvus',
    },
    {
      vector: Array.from({ length: 128 }, () => Math.random()),
      text: 'Vector database',
    },
  ],
});

console.log('Inserted IDs:', insertResult.IDs);

// Create index
await client.createIndex({
  collection_name: 'my_collection',
  field_name: 'vector',
  index_type: 'HNSW',
  metric_type: 'L2',
});

// Load collection
await client.loadCollectionSync({
  collection_name: 'my_collection',
});

// Search
const searchResults = await client.search({
  collection_name: 'my_collection',
  data: [Array.from({ length: 128 }, () => Math.random())],
  limit: 5,
  output_fields: ['text'],
});

console.log('Search results:', searchResults.results);

// Query
const queryResults = await client.query({
  collection_name: 'my_collection',
  expr: 'text == "Hello Milvus"',
  output_fields: ['id', 'text'],
});

console.log('Query results:', queryResults.data);

// Delete
await client.delete({
  collection_name: 'my_collection',
  ids: [insertResult.IDs[0]],
});

// Drop collection
await client.dropCollection({
  collection_name: 'my_collection',
});
```

--------------------------------

### Initialize HttpClient and perform basic operations

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/llms.txt

Shows how to create an HttpClient instance with connection parameters and use it for collection creation, insert, search, and query operations. The example uses snake_case field names and assumes a running Milvus instance.

```typescript
const client = new HttpClient({
  endpoint: 'localhost:19530',
  username: 'root',
  password: 'milvus',
  database: 'default',
  timeout: 60000,
});

await client.createCollection({ collection_name: 'docs', dimension: 128, metric_type: 'COSINE' });
await client.insert({ collection_name: 'docs', data: [{ id: 1, vector: Array(128).fill(0.1) }] });
await client.search({ collection_name: 'docs', data: [Array(128).fill(0.1)], limit: 10 });
await client.query({ collection_name: 'docs', filter: 'id > 0', limit: 100 });
```

--------------------------------

### Create Collection with Time-Based Partition Key

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/getting-started/examples-tutorials.mdx

Shows how to define a partition key for time-based partitioning and insert data, which will be automatically partitioned.

```javascript
// Create collection with partition key
await client.createCollection({
  collection_name: 'time_partitioned',
  fields: [
    {
      name: 'id',
      data_type: DataType.Int64,
      is_primary_key: true,
      autoID: true,
    },
    {
      name: 'vector',
      data_type: DataType.FloatVector,
      dim: 128,
    },
    {
      name: 'timestamp',
      data_type: DataType.Int64,
      is_partition_key: true, // Partition key
    },
  ],
});

// Insert data (automatically partitioned by timestamp)
await client.insert({
  collection_name: 'time_partitioned',
  data: [
    {
      vector: Array.from({ length: 128 }, () => Math.random()),
      timestamp: Date.now(),
    },
  ],
});
```

--------------------------------

### Create Collection, Insert, and Search with MilvusClient

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/README.md

Demonstrates the full workflow: creating a collection with a schema and index, loading it into memory, inserting data, and performing a search with output fields. The search uses consistency_level 'Strong' to include just-inserted rows.

```typescript
import { MilvusClient, DataType, MetricType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({ address: 'localhost:19530' });

// 1. Create collection with schema
await client.createCollection({
  collection_name: 'my_collection',
  fields: [
    {
      name: 'id',
      data_type: DataType.Int64,
      is_primary_key: true,
      autoID: true,
    },
    { name: 'text', data_type: DataType.VarChar, max_length: 512 },
    { name: 'vector', data_type: DataType.FloatVector, dim: 128 },
  ],
  index_params: [
    {
      field_name: 'vector',
      index_type: 'HNSW',
      metric_type: MetricType.COSINE,
      params: { M: 16, efConstruction: 256 },
    },
  ],
  enable_dynamic_field: true,
});

// 2. Load into memory (required before search/query)
await client.loadCollectionSync({ collection_name: 'my_collection' });

// 3. Insert data
await client.insert({
  collection_name: 'my_collection',
  data: [
    { vector: Array(128).fill(0.1), text: 'doc1' },
    { vector: Array(128).fill(0.2), text: 'doc2' },
  ],
});

// 4. Search
const results = await client.search({
  collection_name: 'my_collection',
  data: [Array(128).fill(0.1)],
  limit: 10,
  consistency_level: 'Strong', // Include the rows just inserted
  output_fields: ['text'],
});
console.log(results.results);
```

--------------------------------

### dropFunctionField with example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/collections.mdx

Drops a function together with its output fields and bound indexes. The example removes the 'body_minhash' function from the 'documents' collection.

```typescript
dropFunctionField(data: DropFunctionFieldReq): Promise<ResStatus>
```

```typescript
await client.dropFunctionField({
  collection_name: 'documents',
  function_name: 'body_minhash',
});
```

--------------------------------

### queryIterator usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of using queryIterator to iterate query results in batches. The batchSize is capped at 16384, and limit is optional.

```typescript
const iterator = await client.queryIterator({
  collection_name: 'books',
  filter: 'category == "database"',
  output_fields: ['id', 'title'],
  batchSize: 100,
});

for await (const rows of iterator) {
  console.log(rows);
}
```

--------------------------------

### searchIterator usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of using searchIterator to iterate search results in batches. The batchSize is capped at 16384, and limit is optional.

```typescript
const iterator = await client.searchIterator({
  collection_name: 'books',
  data: [0.1, 0.2, 0.3, 0.4],
  batchSize: 100,
  limit: 1000,
});

for await (const batch of iterator) {
  console.log(batch);
}
```

--------------------------------

### Insert into Default Partition vs Explicit Partition

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/management/partition-management.mdx

Shows how data is inserted into the default `_default` partition when no partition is specified, and how to explicitly specify a partition.

```javascript
// Data goes to _default partition
await client.insert({
  collection_name: 'my_collection',
  data: [
    /* ... */
  ],
});

// Explicitly specify partition
await client.insert({
  collection_name: 'my_collection',
  partition_name: 'partition_1',
  data: [
    /* ... */
  ],
});
```

--------------------------------

### createResourceGroup usage example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/resource-groups.mdx

Example of creating a resource group named 'rg_search' with requests for 2 nodes and limits for 4 nodes.

```typescript
await client.createResourceGroup({
  resource_group: 'rg_search',
  config: {
    requests: { node_num: 2 },
    limits: { node_num: 4 },
  },
});
```

--------------------------------

### Create MilvusClient and HttpClient instances

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/llms.txt

Shows how to instantiate MilvusClient for gRPC (local and cloud) and HttpClient for HTTP/REST. Use token for Zilliz Cloud, or username/password for local Milvus. Await connectPromise to ensure connection.

```typescript
import { MilvusClient, HttpClient } from '@zilliz/milvus2-sdk-node';

const grpcClient = new MilvusClient({ address: 'localhost:19530' });
await grpcClient.connectPromise;

const cloudClient = new MilvusClient({
  address: 'https://your-instance.zillizcloud.com',
  token: 'your-api-key',
});
await cloudClient.connectPromise;

const httpClient = new HttpClient({
  endpoint: 'localhost:19530',
  token: 'optional-token',
});
```

--------------------------------

### get method signature

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

TypeScript signature for the get method, which retrieves rows by primary key. It is a convenience wrapper around query.

```typescript
get(data: GetReq): Promise<QueryResults>
```

--------------------------------

### Import MilvusClient, HttpClient, enums, and BulkWriter

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/README.md

Shows how to import the main client, HTTP client, enums, and bulk writer from the SDK. Use the HTTP client for environments without gRPC support.

```typescript
// Main client
import { MilvusClient } from '@zilliz/milvus2-sdk-node';

// HTTP client (for environments without gRPC support)
import { HttpClient } from '@zilliz/milvus2-sdk-node';

// Enums and constants
import {
  DataType,
  MetricType,
  IndexType,
  ConsistencyLevelEnum,
  ErrorCode,
} from '@zilliz/milvus2-sdk-node';

// Bulk writer for large-scale imports
import { BulkWriter } from '@zilliz/milvus2-sdk-node';
```

--------------------------------

### Deploy to Vercel with CLI

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/advanced/vercel.mdx

Commands to log in to Vercel, deploy the project, and deploy to production.

```bash
# Login to Vercel
vercel login

# Deploy
vercel

# Deploy to production
vercel --prod
```

--------------------------------

### Start Milvus Standalone Docker Container

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/test/cert/README.md

This command starts a standalone Milvus Docker container. Ensure you have the standalone_embed.sh script downloaded and executed.

```bash
cd ~
bash standalone_embed.sh start
```

--------------------------------

### Modify field property example: max_length

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/collections.mdx

Example showing how to set the max_length property to 1024 on the title field of the books collection using alterCollectionFieldProperties.

```typescript
await client.alterCollectionFieldProperties({
  collection_name: 'books',
  field_name: 'title',
  properties: { max_length: 1024 },
});
```

--------------------------------

### Create, List, and Describe Snapshots

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/management/collection-management.mdx

Create, list, and describe snapshots for a collection.

```javascript
await client.createSnapshot({
  collection_name: 'my_collection',
  snapshot_name: 'my_collection_snapshot_001',
  description: 'Before schema migration',
  compaction_protection_seconds: 3600,
});

const snapshots = await client.listSnapshots({
  collection_name: 'my_collection',
});

const snapshot = await client.describeSnapshot({
  collection_name: 'my_collection',
  snapshot_name: 'my_collection_snapshot_001',
});
```

--------------------------------

### Configuration object example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/client.mdx

Constructs a MilvusClient using a configuration object with address, authentication, database, timeout, and retry settings. The connection is awaited via connectPromise.

```typescript
const client = new MilvusClient({
  address: 'localhost:19530',
  ssl: false,
  username: 'root',
  password: 'Milvus',
  database: 'default',
  timeout: 30_000,
  maxRetries: 3,
  retryDelay: 200,
});

await client.connectPromise;
```

--------------------------------

### Search by primary key example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of using the search method with ids to perform a search by primary key. Vector data is not required when ids is provided.

```typescript
const res = await client.search({
  collection_name: 'books',
  ids: [1, 2, 3],
  output_fields: ['title'],
});
```

--------------------------------

### Simple search example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of a basic vector search using the search method. It queries a collection named 'books' with a vector, filter, and output fields.

```typescript
const res = await client.search({
  collection_name: 'books',
  data: [[0.1, 0.2, 0.3, 0.4]],
  anns_field: 'embedding',
  limit: 5,
  filter: 'category == "database"',
  output_fields: ['title', 'category'],
  params: { ef: 64 },
});
```

--------------------------------

### Connect to Milvus with MilvusClient

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/getting-started/getting-started.mdx

Create a MilvusClient instance and connect to a local Milvus server. The SDK automatically connects when the client is created; await client.connectPromise to ensure the connection is established.

```javascript
import { MilvusClient } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530',
});

// Wait for connection to be established
await client.connectPromise;

console.log('Connected to Milvus!');
```

--------------------------------

### Test Your Changes

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/reference/contributing.mdx

Run tests and build to verify changes.

```bash
yarn test
yarn build
```

--------------------------------

### Full Workflow: Write, Upload, Import

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/operations/bulk-writer.mdx

Complete example using BulkWriter to write parquet files, upload them to MinIO/S3, trigger bulk import via MilvusClient.bulkInsert, and poll getImportState until completion. Requires the 'minio' package and a running Milvus instance.

```javascript
import * as Minio from 'minio';

// Step 1: Write files
const writer = new BulkWriter({
  schema: { fields: FIELDS },
  format: 'parquet',
  localPath: './bulk_data',
});

for (const row of data) {
  await writer.append(row);
}
const batchFiles = await writer.close();

// Step 2: Upload to MinIO/S3
const minio = new Minio.Client({
  endPoint: '127.0.0.1',
  port: 9000,
  useSSL: false,
  accessKey: 'minioadmin',
  secretKey: 'minioadmin',
});

const remotePaths = [];
for (const chunk of batchFiles) {
  for (const localFile of chunk) {
    const remote = `imports/${path.basename(localFile)}`;
    await minio.fPutObject('a-bucket', remote, localFile);
    remotePaths.push(remote);
  }
}

// Step 3: Trigger bulk import
const client = new MilvusClient({ address: 'localhost:19530' });
const importRes = await client.bulkInsert({
  collection_name: 'my_collection',
  files: remotePaths,
});

// Step 4: Wait for completion
let state;
do {
  state = await client.getImportState({ task: importRes.tasks[0] });
  await new Promise(r => setTimeout(r, 1000));
} while (state.state !== 'ImportCompleted' && state.state !== 'ImportFailed');

console.log('Import completed, rows:', state.row_count);
```

--------------------------------

### Search aggregation example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of using search_aggregation to group search candidates into buckets, calculate metrics, and create nested buckets. The response is accessed via res.agg_buckets.

```typescript
const res = await client.search({
  collection_name: 'products',
  anns_field: 'embedding',
  data: [0.1, 0.2, 0.3, 0.4],
  limit: 100,
  filter: 'in_stock == true',
  output_fields: ['category', 'brand', 'price'],
  search_aggregation: {
    fields: ['category'],
    size: 5,
    metrics: {
      item_count: { op: 'count', field_name: '*' },
      average_price: { op: 'avg', field_name: 'price' },
    },
    order: [{ key: 'average_price', direction: 'desc' }],
    top_hits: {
      size: 2,
      sort: [{ field_name: 'price', direction: 'asc' }],
    },
    sub_aggregation: {
      fields: ['brand'],
      size: 3,
    },
  },
});

console.log(res.agg_buckets);
```

--------------------------------

### Get entities by IDs using client.get

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/operations/data-operations-query.mdx

Retrieves entities by their IDs using the `get` method. Specify the collection name, an array of IDs, and optional output fields.

```javascript
const results = await client.get({
  collection_name: 'my_collection',
  ids: [1, 2, 3],
  output_fields: ['id', 'vector', 'text'],
});
```

--------------------------------

### Set Active Database Context and Create Collection

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/databases.mdx

Demonstrates setting the active database using `client.use` and then creating a collection within that database context.

```typescript
await client.createDatabase({ db_name: 'analytics' });
await client.use({ db_name: 'analytics' });

await client.createCollection({
  collection_name: 'events',
  dimension: 128,
});
```

--------------------------------

### Drop field example using dropCollectionField

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/collections.mdx

Example usage of dropCollectionField to drop the legacy_category field from the books collection. The field_name option is used; provide either field_name or field_id, not both.

```typescript
await client.dropCollectionField({
  collection_name: 'books',
  field_name: 'legacy_category',
});
```

--------------------------------

### End-to-End Hybrid Search Example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/operations/hybrid-search.mdx

This snippet demonstrates the complete lifecycle of a hybrid search operation, from collection creation to cleanup. It requires the Milvus client to be initialized and accessible.

```javascript
import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({ address: 'localhost:19530' });

// 1. Create a collection with two vector fields
await client.createCollection({
  collection_name: 'hybrid_demo',
  fields: [
    {
      name: 'id',
      data_type: DataType.Int64,
      is_primary_key: true,
      autoID: true,
    },
    { name: 'text', data_type: DataType.VarChar, max_length: 512 },
    { name: 'dense_vector', data_type: DataType.FloatVector, dim: 4 },
    { name: 'sparse_vector', data_type: DataType.SparseFloatVector },
  ],
});

// 2. Create indexes for both vector fields
await client.createIndex({
  collection_name: 'hybrid_demo',
  index_params: [
    {
      field_name: 'dense_vector',
      index_type: 'AUTOINDEX',
      metric_type: 'COSINE',
    },
    {
      field_name: 'sparse_vector',
      index_type: 'SPARSE_INVERTED_INDEX',
      metric_type: 'IP',
    },
  ],
});

// 3. Load collection
await client.loadCollectionSync({ collection_name: 'hybrid_demo' });

// 4. Insert data
await client.insert({
  collection_name: 'hybrid_demo',
  data: [
    {
      text: 'machine learning fundamentals',
      dense_vector: [0.1, 0.2, 0.3, 0.4],
      sparse_vector: { 10: 0.5, 20: 0.3 },
    },
    {
      text: 'deep learning neural networks',
      dense_vector: [0.5, 0.6, 0.7, 0.8],
      sparse_vector: { 15: 0.8, 25: 0.2 },
    },
  ],
});

// 5. Hybrid search
const results = await client.hybridSearch({
  collection_name: 'hybrid_demo',
  data: [
    {
      data: [0.1, 0.2, 0.3, 0.4],
      anns_field: 'dense_vector',
    },
    {
      data: { 10: 0.5, 20: 0.3 },
      anns_field: 'sparse_vector',
    },
  ],
  rerank: {
    strategy: 'rrf',
    params: { k: 60 },
  },
  limit: 10,
  output_fields: ['text'],
});

console.log('Results:', results.results);

// 6. Cleanup
await client.dropCollection({ collection_name: 'hybrid_demo' });
```

--------------------------------

### Update SDK Package

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/reference/migration-compatibility.mdx

Use these commands to update the SDK package to the latest version or a specific version. The first command installs the latest version, while the second installs version 2.6.

```bash
yarn add @zilliz/milvus2-sdk-node@latest
# or specific version
yarn add @zilliz/milvus2-sdk-node@2.6
```

--------------------------------

### Clone Repository

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/reference/contributing.mdx

Clone the repository and navigate into the project directory.

```bash
git clone https://github.com/milvus-io/milvus-sdk-node.git
cd milvus-sdk-node
```

--------------------------------

### Initialize MilvusClient (gRPC) and HttpClient (HTTP) for Node.js

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/getting-started/deployment.mdx

Shows how to create a Milvus client for a traditional Node.js server using either the gRPC client (recommended) or the HTTP client. The gRPC client uses an address and token, while the HTTP client uses a baseURL and token. Both clients are imported from the '@zilliz/milvus2-sdk-node' package.

```javascript
// Using gRPC Client (Recommended)
import { MilvusClient } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530',
  token: 'your-token',
});

await client.connectPromise;

// Using HTTP Client
import { HttpClient } from '@zilliz/milvus2-sdk-node';

const client = new HttpClient({
  baseURL: 'http://localhost:19530',
  token: 'your-token',
});
```

--------------------------------

### Insert example for books collection

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of inserting a single row into the 'books' collection. The data array contains one object with fields id, title, embedding, and category. The response is a MutationResult.

```typescript
const res = await client.insert({
  collection_name: 'books',
  data: [
    {
      id: 1,
      title: 'Vector databases',
      embedding: [0.1, 0.2, 0.3, 0.4],
      category: 'database',
    },
  ],
});
```

--------------------------------

### Query, Get, Count, and Delete Operations

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/llms.txt

Demonstrates querying with a filter, getting rows by IDs, counting rows matching a filter, and deleting by IDs or by filter. These are separate operations on the 'documents' collection.

```typescript
const rows = await client.query({
  collection_name: 'documents',
  filter: 'source == "file1.pdf"',
  output_fields: ['text', 'source'],
  limit: 100,
});
```

```typescript
const byIds = await client.get({
  collection_name: 'documents',
  ids: [1, 2, 3],
  output_fields: ['text'],
});
```

```typescript
const count = await client.count({
  collection_name: 'documents',
  filter: 'source != ""',
});
```

```typescript
await client.delete({ collection_name: 'documents', ids: [1, 2, 3] });
await client.delete({ collection_name: 'documents', filter: 'source == "old.pdf"' });
```

--------------------------------

### Quick Start: Connect to Milvus with MilvusClient

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/index.mdx

Initializes a MilvusClient to connect to a local Milvus instance at localhost:19530. Requires Node.js 18 or higher and a running Milvus instance. The connection is established by awaiting the client's connectPromise.

```javascript
import { MilvusClient } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530',
});

await client.connectPromise;

console.log('Connected to Milvus!');
```

--------------------------------

### Create collection with partition configuration

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/management/collection-management.mdx

Creates a collection with a specified number of partitions (8).

```javascript
await client.createCollection({
  collection_name: 'my_collection',
  fields: schema,
  num_partitions: 8, // Number of partitions
});
```

--------------------------------

### Zilliz Cloud Deployment Configuration

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/getting-started/examples-tutorials.mdx

Example configuration for connecting to Zilliz Cloud with additional options like timeout and max retries.

```javascript
const client = new MilvusClient({
  address: 'your-endpoint.zillizcloud.com:443',
  token: 'your-api-key',
  ssl: true,
  timeout: 60000,
  maxRetries: 5,
});

await client.connectPromise;

// Use client as normal
await client.createCollection({ /* ... */ });
```

--------------------------------

### Upsert with field_ops partial update example

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/docs/src/content/docs/api-reference/data.mdx

Example of upsert with partial field updates. It imports FieldPartialUpdateOpType and uses field_ops to append to the 'tags' and 'scores' arrays. Providing field_ops automatically enables partial update behavior.

```typescript
import { FieldPartialUpdateOpType } from '@zilliz/milvus2-sdk-node';

await client.upsert({
  collection_name: 'books',
  data: [{ id: 1, tags: ['database'], scores: [0.9] }],
  field_ops: [
    { field_name: 'tags', op: FieldPartialUpdateOpType.ARRAY_APPEND },
    { field_name: 'scores', op: 'ARRAY_APPEND' },
  ],
});
```

--------------------------------

### Run the Application

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/examples/LangChain/README.md

Execute the JavaScript file using Node.js.

```shell
node LangChain.js
```

--------------------------------

### Build Project

Source: https://github.com/milvus-io/milvus-sdk-node/blob/main/CLAUDE.md

Builds the project by cleaning the dist directory, compiling TypeScript, and generating sdk.json.

```bash
yarn build
```
Tokens:
Raw