Zilliz Cloud

https://docs.zilliz.com/docs
Admin
Zilliz Cloud offers a fully managed Milvus service for simplified deployment and scaling of vector...
Tokens:747,373
Snippets:7,732
Trust Score:10
Update:4 months ago
Show doc for...
Tokens:
Raw
### Quickstart Command

Source: https://docs.zilliz.com/docs/agents/zilliz-plugin

Run the quickstart command to initiate the setup process for the Zilliz plugin. This includes CLI installation, authentication, cluster connection, and initial operations.

```plaintext
/zilliz:quickstart
```

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

### Install and Start VectorDBBench

Source: https://docs.zilliz.com/docs/perf-benchmark-vectordb

Install the VectorDBBench library using pip and start the application. The start command provides a local URL to access the web UI.

```bash
# Install VectorDBBench
$ pip install vectordb-bench

# Start VectorDBBench
$ init_bench
```

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

### Go Get and Query Examples

Source: https://docs.zilliz.com/docs/byoc/get-and-scalar-query

Shows how to perform get and query operations in Go, including setting partitions, IDs, filters, and output fields. Error handling is included.

```go
resultSet, err := client.Get(ctx, milvusclient.NewQueryOption("my_collection").
    WithPartitions("partitionA").
    WithIDs(column.NewColumnInt64("id", []int64{10, 11, 12})).
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())

resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection").
    WithPartitions("partitionA").
    WithFilter("color like \"red%\"").
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())
```

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

### JavaScript Get, Query, and Query Iterator Examples

Source: https://docs.zilliz.com/docs/byoc/get-and-scalar-query

Illustrates using get, query, and queryIterator methods in JavaScript. Highlights setting partition names, IDs, filters, and iterating through results.

```javascript
// Use get
var res = client.get({
    collection_name="my_collection",
    // highlight-next-line
    partition_names=["partitionA"],
    ids=[10,11,12],
    output_fields=["vector", "color"]
})

// Use query
res = client.query({
    collection_name="my_collection",
    // highlight-next-line
    partition_names=["partitionA"],
    filter="color like \"red%\"",
    output_fields=["vector", "color"],
    limit(3)
})

// Use queryiterator
const iterator = await milvusClient.queryIterator({
  collection_name: 'my_collection',
  partition_names: ['partitionA'],
  batchSize: 10,
  expr: 'color like "red%"',
  output_fields: ['vector', 'color'],
});

const results = [];
for await (const value of iterator) {
  results.push(...value);
  page += 1;
}
```

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

### VectorDBBench Welcome Output

Source: https://docs.zilliz.com/docs/perf-benchmark-vectordb

Example output when starting VectorDBBench, including welcome messages and local/network URLs for the web interface. It also provides information on telemetry and how to opt out.

```python

      👋 Welcome to Streamlit! 

      If you’d like to receive helpful onboarding emails, news, offers, promotions,
      and the occasional swag, please enter your email address below. Otherwise,
      leave this field blank.

      Email:  
  You can find our privacy policy at https://streamlit.io/privacy-policy

  Summary:
  - This open source library collects usage statistics.
  - We cannot see and do not store information contained inside Streamlit apps,
    such as text, charts, images, etc.
  - Telemetry data is stored in servers in the United States.
  - If you'd like to opt out, add the following to ~/.streamlit/config.toml,
    creating that file if necessary:

    [browser] 
    gatherUsageStats = false

  You can now view your Streamlit app in your browser.

  Local URL: http://localhost:8501
  Network URL: http://172.16.20.46:8501

```

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

### Java Get, Query, and Query Iterator Examples

Source: https://docs.zilliz.com/docs/byoc/get-and-scalar-query

Demonstrates building requests for get, query, and query iterator operations in Java. Includes setting collection name, partition, IDs, filters, and output fields.

```java
GetReq getReq = GetReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .ids(Arrays.asList(10, 11, 12))
        .outputFields(Collections.singletonList("color"))
        .build();

GetResp getResp = client.get(getReq);

QueryReq queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .filter("color like \"red%\"")
        .outputFields(Collections.singletonList("color"))
        .limit(3)
        .build();

QueryResp getResp = client.query(queryReq);

QueryIteratorReq req = QueryIteratorReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .expr("color like \"red%\"")
        .batchSize(50L)
        .outputFields(Collections.singletonList("color"))
        .consistencyLevel(ConsistencyLevel.BOUNDED)
        .build();
QueryIterator queryIterator = client.queryIterator(req);
```

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

### Install Go SDK

Source: https://docs.zilliz.com/docs/byoc/install-sdks

Use this command to install the Go SDK compatible with Milvus v2.5.x.

```bash
# Install Go SDK compatible with Milvus v2.5.x
go get -u github.com/milvus-io/milvus-sdk-go/v2@v2.5.6
```

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

### Jieba Tokenizer Configuration Example (Go)

Source: https://docs.zilliz.com/docs/jieba-tokenizer

Example of configuring the Jieba tokenizer with a custom dictionary and exact mode in Go.

```go
analyzerParams := map[string]interface{}{
  "tokenizer": map[string]interface{}{
      "type": "jieba",
      "dict": []string{"结巴分词器"},
      "mode": "exact",
      "hmm":  false,
  },
}

```

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

### Run Zilliz Gemini CLI Extension Setup Wizard

Source: https://docs.zilliz.com/docs/agents/zilliz-gemini-extension

Initiate the setup wizard for the Zilliz Gemini CLI Extension to configure your environment.

```bash
/zilliz:setup
```

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

### Install Zilliz Plugin

Source: https://docs.zilliz.com/docs/agents/zilliz-plugin-setup

Install the Zilliz plugin from the added marketplace.

```bash
/plugin install zilliz@zilliztech/zilliz-plugin
```

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

### Jieba Tokenizer Configuration Example (Java)

Source: https://docs.zilliz.com/docs/jieba-tokenizer

Example of configuring the Jieba tokenizer with a custom dictionary and exact mode in Java.

```java
Map<String, Object> analyzerParams = new HashMap<>();                                                                          
analyzerParams.put("tokenizer", new HashMap<String, Object>() {{                                                                                                      
  put("type", "jieba");                                                                                                      
  put("dict", Arrays.asList("结巴分词器"));                   
  put("mode", "exact");
  put("hmm", false);
}});

```

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

### Jieba Tokenizer Configuration Example (Python)

Source: https://docs.zilliz.com/docs/jieba-tokenizer

Example of configuring the Jieba tokenizer with a custom dictionary and exact mode in Python.

```python
analyzer_params = {
    "tokenizer": {
        "type": "jieba",
        "dict": ["结巴分词器"],
        "mode": "exact",
        "hmm": False
    }
}

```

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

### Install Zilliz Skill

Source: https://docs.zilliz.com/docs/agents/zilliz-skill

Run this command to install the Zilliz skill. Ensure Node.js is installed. The command will guide you through choosing target tools and installation scope.

```bash
npx skills add zilliztech/zilliz-skill
```

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

### Create and List Partitions in Go

Source: https://docs.zilliz.com/docs/byoc/manage-partitions

Illustrates creating a partition and listing all partitions for a collection using the Milvus Go SDK. Ensure context is managed and errors are handled.

```go
import (
    "fmt"
    
    client "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
deferr cancel()

err = client.CreatePartition(ctx, milvusclient.NewCreatePartitionOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

partitionNames, err := client.ListPartitions(ctx, milvusclient.NewListPartitionOption("my_collection"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println(partitionNames)
// Output
// ["_default", "partitionA"]
```

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

### Get Entities by IDs in Go

Source: https://docs.zilliz.com/docs/byoc/get-and-scalar-query

Retrieve entities from Milvus using their primary keys in Go. This example demonstrates setting up the client, context, and constructing the Get request.

```go
import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
deferr cancel()

milvusAddr := "YOUR_CLUSTER_ENDPOINT"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: milvusAddr,
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
deferr client.Close(ctx)

resultSet, err := client.Get(ctx, milvusclient.NewQueryOption("my_collection").
    WithConsistencyLevel(entity.ClStrong).
    WithIDs(column.NewColumnInt64("id", []int64{0, 1, 2})).
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())
```

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

### Create and List Partitions in Java

Source: https://docs.zilliz.com/docs/byoc/manage-partitions

Demonstrates creating a partition and listing all partitions for a collection using the Milvus Java SDK. Requires necessary imports and an initialized client.

```java
import io.milvus.v2.service.partition.request.CreatePartitionReq;

CreatePartitionReq createPartitionReq = CreatePartitionReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

client.createPartition(createPartitionReq);

ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
        .collectionName("my_collection")
        .build();

List<String> partitionNames = client.listPartitions(listPartitionsReq);
System.out.println(partitionNames);

// Output:
// [_default, partitionA]
```

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

### Check uv Version

Source: https://docs.zilliz.com/docs/byoc/zilliz-mcp-server

Confirm that uv is installed and accessible in your PATH. uv is a fast Python package installer and dependency resolver required for the MCP Server setup.

```bash
uv -V
```

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

### Example Collection List Output

Source: https://docs.zilliz.com/docs/byoc/view-collections

This JSON output shows the expected result when listing collections, assuming a collection named 'quick_setup' already exists.

```json
["quick_setup"]
```

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

### Create and List Partitions using cURL

Source: https://docs.zilliz.com/docs/byoc/manage-partitions

This example shows how to create a partition and list partitions for a collection using cURL commands. Ensure your cluster endpoint and token are set as environment variables.

```bash
export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionName": "partitionA"
}'

# {
#     "code": 0,
#     "data": {}
# }

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/list" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection"
}'

# {
#     "code": 0,
#     "data": [
#         "_default",
#         "partitionA"
#     ]
# }
```

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

### Example Output for Listing Projects

Source: https://docs.zilliz.com/docs/byoc/manage-projects

This is an example of the JSON response when listing all projects, showing details like project name, ID, instance count, and creation time.

```json
{
  "code": 0,
  "data": [
    {
      "projectName": "project1",
      "projectId": "proj-a0195d6acacaf2bb985173",
      "instanceCount": 3,
      "createTime": "2023-12-07T03:21:32Z",
      "plan": "Standard",
      "projectType": "Regional",
      "regions": ["aws-us-west-2"]
    },
    {
      "projectName": "Default Project",
      "projectId": "proj-412e874430bfa02e857247",
      "instanceCount": 0,
      "createTime": "2023-08-16T07:34:06Z",
      "plan": "Enterprise",
      "projectType": "Legacy",
      "regions": []
    }
  ]
}
```

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

### Bash Get and Query Examples

Source: https://docs.zilliz.com/docs/byoc/get-and-scalar-query

Shows how to use curl to perform get and query operations via REST API. Includes setting endpoint, token, collection name, partitions, IDs, filters, and output fields.

```bash
export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

# Use get
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/get" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{ \
    "collectionName": "my_collection", \
    "partitionNames": ["partitionA"], \
    "id": [10, 11, 12], \
    "outputFields": ["vector", "color"] \
}'

# Use query
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/get" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{ \
    "collectionName": "my_collection", \
    "partitionNames": ["partitionA"], \
    "filter": "color like \"red%\"", \
    "limit": 3, \
    "outputFields": ["vector", "color"], \
    "id": [0, 1, 2] \
}'
```

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

### Zilliz Skill Usage Examples

Source: https://docs.zilliz.com/docs/agents/zilliz-skill

These are examples of natural language prompts you can use to invoke Zilliz Skills for various Zilliz Cloud operations. They cover cluster creation, collection setup, data searching, status monitoring, backup policies, and user role management.

```plaintext
"Create a serverless cluster in us-east-1 and set up a collection with 768-dimension vectors"
```

```plaintext
"Search for similar items in my product collection with filter age > 20"
```

```plaintext
"Show me the status of all my clusters and collections"
```

```plaintext
"Set up a daily backup policy for my production cluster with 7-day retention"
```

```plaintext
"Create a role with read-only access to the analytics collection"
```

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

### Elasticsearch Prefix Query

Source: https://docs.zilliz.com/docs/byoc/elasticsearch-queries-to-milvus

Example of an Elasticsearch search request to find documents where a field starts with a specific prefix, used within a filter context.

```python
resp = client.search(
    query={
        "bool": {
            "filter": {
                 "prefix": {
                    "user": {
                        "value": "ki"
                    }
                }           
            }
        }
    },
)


```

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

### Connect to Milvus and Create Collection (Java)

Source: https://docs.zilliz.com/docs/byoc/export-data-iterators

Establishes a connection to the Milvus server and creates a collection named 'quick_setup' with a dimension of 5. Replace 'YOUR_CLUSTER_ENDPOINT' and 'YOUR_CLUSTER_TOKEN' with your specific cluster details.

```java
import io.milvus.client.MilvusServiceClient;
import io.milvus.param.ConnectParam;
import io.milvus.param.highlevel.collection.CreateSimpleCollectionParam;

String CLUSTER_ENDPOINT = "YOUR_CLUSTER_ENDPOINT";
String TOKEN = "YOUR_CLUSTER_TOKEN";

// 1. Connect to Milvus server
ConnectParam connectParam = ConnectParam.newBuilder()
        .withUri(CLUSTER_ENDPOINT)
        .withToken(TOKEN)
        .build();

MilvusServiceClient client  = new MilvusServiceClient(connectParam);

// 2. Create a collection
CreateSimpleCollectionParam createCollectionParam = CreateSimpleCollectionParam.newBuilder()
        .withCollectionName("quick_setup")
        .withDimension(5)
        .build();

client.createCollection(createCollectionParam);
```

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

### Get Entities by IDs in Go

Source: https://docs.zilliz.com/docs/get-and-scalar-query

Fetch entities using their IDs in Go. This example demonstrates retrieving specific fields like 'vector' and 'color'.

```go
resultSet, err := client.Get(ctx, milvusclient.NewQueryOption("my_collection").
    WithPartitions("partitionA").
    WithIDs(column.NewColumnInt64("id", []int64{10, 11, 12})).
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())
```

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

### Create Milvus Client and Collection (Python)

Source: https://docs.zilliz.com/docs/byoc/export-data-iterators

Initializes a Milvus client and creates a collection named 'quick_setup' with a dimension of 5. Ensure you replace 'YOUR_CLUSTER_ENDPOINT' and 'YOUR_CLUSTER_TOKEN' with your actual credentials.

```python
from pymilvus import MilvusClient

CLUSTER_ENDPOINT = "YOUR_CLUSTER_ENDPOINT"
TOKEN = "YOUR_CLUSTER_TOKEN"

# 1. Set up a Milvus client
client = MilvusClient(
    uri=CLUSTER_ENDPOINT,
    token=TOKEN 
)

# 2. Create a collection
client.create_collection(
    collection_name="quick_setup",
    dimension=5,
)
```

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

### Create and List Partitions in NodeJS

Source: https://docs.zilliz.com/docs/byoc/manage-partitions

Shows how to create a partition and list all partitions for a collection using the Milvus NodeJS client. Asynchronous operations should be handled with await.

```javascript
await client.createPartition({
    collection_name: "my_collection",
    partition_name: "partitionA"
})

res = await client.listPartitions({
    collection_name: "my_collection"
})

console.log(res)

// Output
// ["_default", "partitionA"]
```

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

### Example Output for Get Backup Policy

Source: https://docs.zilliz.com/docs/byoc/schedule-automatic-backups

This JSON structure represents the response when querying the automatic backup policy. It includes status, schedule, and retention details.

```json
{
    "code": 0,
    "data": {
        "clusterId": "inxx-xxxxxxxxxxxxxxx",
        "status": "ENABLED",
        "startTime": "02:00-04:00",
        "frequency": "1,2,3,5",
        "retentionDays": 7,
        "crossRegionPolicies": [
            {
                "regionId": "aws-us-west-2",
                "retentionDays": 7,
                "region": "us-west-2"
            },
            {
                "regionId": "aws-us-east-1",
                "retentionDays": 7,
                "region": "us-east-1"
            }
        ]
    }
}
```

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

### Get Entities by IDs in Java

Source: https://docs.zilliz.com/docs/byoc/get-and-scalar-query

Fetch entities from Milvus using their IDs. This example shows how to build the request and iterate through the results, printing entity details.

```java
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.GetReq
import io.milvus.v2.service.vector.request.GetResp
import io.milvus.v2.service.vector.response.QueryResp;
import java.util.*;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("YOUR_CLUSTER_ENDPOINT")
        .token("YOUR_CLUSTER_TOKEN")
        .build());
        
GetReq getReq = GetReq.builder()
        .collectionName("my_collection")
        .ids(Arrays.asList(0, 1, 2))
        .outputFields(Arrays.asList("vector", "color"))
        .build();

GetResp getResp = client.get(getReq);

List<QueryResp.QueryResult> results = getResp.getGetResults();
for (QueryResp.QueryResult result : results) {
    System.out.println(result.getEntity());
}

// Output
// {color=pink_8682, vector=[0.35803765, -0.6023496, 0.18414013, -0.26286206, 0.90294385], id=0}
// {color=red_7025, vector=[0.19886813, 0.060235605, 0.6976963, 0.26144746, 0.8387295], id=1}
// {color=orange_6781, vector=[0.43742132, -0.55975026, 0.6457888, 0.7894059, 0.20785794], id=2}
```

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

### Backup Configuration Example (backup.yaml)

Source: https://docs.zilliz.com/docs/byoc/via-backup-files

Shows essential configuration parameters for milvus-backup, including Milvus proxy address and Minio/S3 storage details like bucket names and root paths.

```yaml
...
# milvus proxy address, compatible to milvus.yaml
milvus:
  address: localhost
  port: 19530
  ...
  
# Related configuration of minio, which is responsible for data persistence for Milvus.
minio:
  # Milvus storage configs, make them the same with milvus config
  storageType: "minio" # support storage type: local, minio, s3, aws, gcp, ali(aliyun), azure, tc(tencent), gcpnative
  # You can use "gcpnative" for the Google Cloud Platform provider. Uses service account credentials for authentication.
  address: localhost # Address of MinIO/S3
  port: 9000   # Port of MinIO/S3
  bucketName: "a-bucket" # Milvus Bucket name in MinIO/S3, make it the same as your milvus instance
  backupBucketName: "a-bucket" # Bucket name to store backup data. Backup data will store to backupBucketName/backupRootPath
  rootPath: "files" # Milvus storage root path in MinIO/S3, make it the same as your milvus instance
  ...

```

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

### Query Entities by Filter

Source: https://docs.zilliz.com/docs/byoc/get-and-scalar-query

Use the Query method to find entities that match a specific filter condition. This example retrieves entities where the 'color' field starts with 'red'.

```python
from pymilvus import MilvusClient

client = MilvusClient(
    uri="YOUR_CLUSTER_ENDPOINT",
    token="YOUR_CLUSTER_TOKEN"
)

res = client.query(
    collection_name="my_collection",
    filter="color like \"red%\"",
    output_fields=["vector", "color"],
    limit=3
)
```

```java
import io.milvus.v2.service.vector.request.QueryReq
import io.milvus.v2.service.vector.request.QueryResp

QueryReq queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .filter("color like \"red%\"")
        .outputFields(Arrays.asList("vector", "color"))
        .limit(3)
        .build();

QueryResp queryResp = client.query(queryReq);

List<QueryResp.QueryResult> results = queryResp.getQueryResults();
for (QueryResp.QueryResult result : results) {
    System.out.println(result.getEntity());
}

// Output
// {color=red_7025, vector=[0.19886813, 0.060235605, 0.6976963, 0.26144746, 0.8387295], id=1}
// {color=red_4794, vector=[0.44523495, -0.8757027, 0.82207793, 0.4640629, 0.3033748], id=4}
// {color=red_9392, vector=[0.8371978, -0.015764369, -0.31062937, -0.56266695, -0.8984948], id=6}
```

```go
resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection").
    WithFilter("color like \"red%\"").
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())
```

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

const address = "YOUR_CLUSTER_ENDPOINT";
const token = "YOUR_CLUSTER_TOKEN";
const client = new MilvusClient({address, token});

const res = client.query({
    collection_name="my_collection",
    filter='color like "red%"',
    output_fields=["vector", "color"],
    limit(3)
})
```

```bash
export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "filter": "color like \"red%\"",
    "limit": 3,
    "outputFields": ["vector", "color"]
}'
#{"code":0,"cost":0,"data":[{"color":"red_7025","id":1,"vector":[0.19886813,0.060235605,0.6976963,0.26144746,0.8387295]},{"color":"red_4794","id":4,"vector":[0.44523495,-0.8757027,0.82207793,0.4640629,0.3033748]},{"color":"red_9392","id":6,"vector":[0.8371978,-0.015764369,-0.31062937,-0.56266695,-0.8984948]}]}
```

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

### Perform Similarity Search with Boost Ranker (JavaScript)

Source: https://docs.zilliz.com/docs/boost-ranker

This JavaScript example demonstrates how to configure and use Boost Rankers with a Function Score for similarity searches. Ensure the '@zilliz/milvus2-sdk-node' is installed.

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

const fix_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    weight: 0.8,
  },
};

const random_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    random_score: {
      seed: 126,
    },
    weight: 0.4,
  },
};

const ranker = {
  functions: [fix_weight_ranker, random_weight_ranker],
  params: {
    boost_mode: "Multiply",
    function_mode: "Sum",
  },
};

await client.search({
  collection_name: "my_collection",
  data: [[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
  anns_field: "vector",
  params: {},
  output_field: ["doctype"],
  ranker: ranker
});

```

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

### Initialize Milvus Client and Create Schema (Go)

Source: https://docs.zilliz.com/docs/analyzer-overview

Sets up a Milvus client with context and creates a schema, enabling auto ID and disabling dynamic fields.

```go
import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/index"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
deferr cancel()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "YOUR_CLUSTER_ENDPOINT",
    token: "YOUR_CLUSTER_TOKEN"
})
if err != nil {
    fmt.Println(err.Error())
    // handle err
}
deferr client.Close(ctx)

schema := entity.NewSchema().WithAutoID(true).WithDynamicFieldEnabled(false)
```

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

### Verify Cncharonly Filter Configuration in Python

Source: https://docs.zilliz.com/docs/cncharonly-filter

Before applying the analyzer configuration to your collection schema, verify its behavior using the `run_analyzer` method in Python. This example shows the basic setup.

```python
from pymilvus import (
    MilvusClient,
)

client = MilvusClient(uri="YOUR_CLUSTER_ENDPOINT")

# Sample text to analyze
sample_text = "Milvus 是 LF AI & Data Foundation 下的一个开源项目，以 Apache 2.0 许可发布。"

```

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

### Run Jieba Analyzer with Configuration (Go)

Source: https://docs.zilliz.com/docs/byoc/jieba-tokenizer

Demonstrates how to call the `RunAnalyzer` method in Go, passing the sample text and analyzer parameters. Includes error handling for client creation and the API call.

```go
import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "YOUR_CLUSTER_ENDPOINT",
    APIKey:  "YOUR_CLUSTER_TOKEN",
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

bs, _ := json.Marshal(analyzerParams)
texts := []string{"milvus结巴分词器中文测试"}
option := milvusclient.NewRunAnalyzerOption(texts).
    WithAnalyzerParams(string(bs))

result, err := client.RunAnalyzer(ctx, option)
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
```

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

### List Roles using Go SDK

Source: https://docs.zilliz.com/docs/cluster-roles-sdk

This Go SDK example shows how to list all available roles in the Milvus cluster. It requires a background context.

```go
import "github.com/milvus-io/milvus-sdk-go/v2/client"

client.ListRoles(context.Background())
```

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

### Query Entities by String Pattern

Source: https://docs.zilliz.com/docs/get-and-scalar-query

Use the Query method to find entities where a specific field matches a string pattern. This example filters for entities with a 'color' field starting with 'red'.

```python
from pymilvus import MilvusClient

client = MilvusClient(
    uri="YOUR_CLUSTER_ENDPOINT",
    token="YOUR_CLUSTER_TOKEN"
)

res = client.query(
    collection_name="my_collection",
    filter="color like \"red%\"",
    output_fields=["vector", "color"],
    limit=3
)
```

```java
import io.milvus.v2.service.vector.request.QueryReq
import io.milvus.v2.service.vector.request.QueryResp

QueryReq queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .filter("color like \"red%\"")
        .outputFields(Arrays.asList("vector", "color"))
        .limit(3)
        .build();

QueryResp queryResp = client.query(queryReq);

List<QueryResp.QueryResult> results = queryResp.getQueryResults();
for (QueryResp.QueryResult result : results) {
    System.out.println(result.getEntity());
}

// Output
// {color=red_7025, vector=[0.19886813, 0.060235605, 0.6976963, 0.26144746, 0.8387295], id=1}
// {color=red_4794, vector=[0.44523495, -0.8757027, 0.82207793, 0.4640629, 0.3033748], id=4}
// {color=red_9392, vector=[0.8371978, -0.015764369, -0.31062937, -0.56266695, -0.8984948], id=6}
```

```go
resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection")
    .WithFilter("color like \"red%\"")
    .WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())
```

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

const address = "YOUR_CLUSTER_ENDPOINT";
const token = "YOUR_CLUSTER_TOKEN";
const client = new MilvusClient({address, token});

const res = client.query({
    collection_name="my_collection",
    filter='color like "red%"',
    output_fields=["vector", "color"],
    limit(3)
})
```

```bash
export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "filter": "color like \"red%\"",
    "limit": 3,
    "outputFields": ["vector", "color"]
}'
#{"code":0,"cost":0,"data":[{"color":"red_7025","id":1,"vector":[0.19886813,0.060235605,0.6976963,0.26144746,0.8387295]},{"color":"red_4794","id":4,"vector":[0.44523495,-0.8757027,0.82207793,0.4640629,0.3033748]},{"color":"red_9392","id":6,"vector":[0.8371978,-0.015764369,-0.31062937,-0.56266695,-0.8984948]}]}
```

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

### Configure Stop Filter with Inline Stop Words (cURL)

Source: https://docs.zilliz.com/docs/stop-filter

Use this cURL example to configure the stop filter with an inline list of stop words. This is typically used in RESTful API requests for text analysis setup.

```bash
# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "stop",
      "stop_words": [
        "of",
        "to",
        "_english_"
      ]
    }
  ]
}'

```

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

### Release, Drop, and List Partitions in Go

Source: https://docs.zilliz.com/docs/byoc/manage-partitions

Provides Go code examples for managing partitions in Milvus. This covers releasing, dropping, and listing partitions, including basic error handling.

```go
err = client.ReleasePartitions(ctx, milvusclient.NewReleasePartitionsOptions("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

err = client.DropPartition(ctx, milvusclient.NewDropPartitionOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

partitionNames, err := client.ListPartitions(ctx, milvusclient.NewListPartitionOption("my_collection"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println(partitionNames)
```

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

### Install VectorDBBench

Source: https://docs.zilliz.com/docs/byoc/perf-benchmark-vectordb

Install the VectorDBBench package using pip. Ensure you have Python 3.11 or later installed.

```bash
# Install VectorDBBench
$ pip install vectordb-bench

```

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

### Set up Milvus Client and Create Collection (Java)

Source: https://docs.zilliz.com/docs/byoc/data-import-zero-to-hero

Initializes a Milvus client with connection configuration, defines index parameters for various vector types, and creates a collection using a builder pattern.

```java
import com.google.common.collect.Lists;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import java.util.List;

// 1. Set up a Milvus client
MilvusClientV2 milvusClient = new MilvusClientV2(ConnectConfig.builder()
        .uri(CLUSTER_ENDPOINT)
        .token(API_KEY)
        .build());

// 2. Set index parameters
IndexParam floatVectorIndex = IndexParam.builder()
        .fieldName("float_vector")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.IP)
        .build();

IndexParam binaryVectorIndex = IndexParam.builder()
        .fieldName("binary_vector")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.HAMMING)
        .build();

IndexParam float16VectorIndex = IndexParam.builder()
        .fieldName("float16_vector")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.IP)
        .build();

IndexParam sparseVectorIndex = IndexParam.builder()
        .fieldName("sparse_vector")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.IP)
        .build();

List<IndexParam> indexParamList = Lists.newArrayList(
        floatVectorIndex,
        binaryVectorIndex,
        float16VectorIndex,
        sparseVectorIndex
);

// 3. Create collection
CreateCollectionReq.CollectionSchema schema = createSchema();
CreateCollectionReq request = CreateCollectionReq.builder()
        .collectionName(COLLECTION_NAME)
        .collectionSchema(schema)
        .indexParams(indexParamList)
        .build();
milvusClient.createCollection(request);
```

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

### Verify Zilliz CLI Installation

Source: https://docs.zilliz.com/docs/agents/zilliz-gemini-extension

Check the installed version of the Zilliz CLI to confirm successful installation.

```bash
zilliz --version
```

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

### Install Dependencies for ColBERT

Source: https://docs.zilliz.com/docs/byoc/search-with-embeddinglist

Installs necessary Python packages for setting up a ColBERT text retrieval system. Ensure you have Python and pip installed.

```shell
pip install --upgrade huggingface-hub transformers datasets pymilvus cohere
```

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

### Release, Drop, and List Partitions in Java

Source: https://docs.zilliz.com/docs/byoc/manage-partitions

Demonstrates how to release, drop, and list partitions for a collection using the Milvus Java SDK. Ensure the Milvus client is initialized before use.

```java
import io.milvus.v2.service.partition.request.DropPartitionReq;
import io.milvus.v2.service.partition.request.ReleasePartitionsReq;
import io.milvus.v2.service.partition.request.ListPartitionsReq;

ReleasePartitionsReq releasePartitionsReq = ReleasePartitionsReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .build();

client.releasePartitions(releasePartitionsReq);

DropPartitionReq dropPartitionReq = DropPartitionReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

client.dropPartition(dropPartitionReq);

ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
        .collectionName("my_collection")
        .build();

List<String> partitionNames = client.listPartitions(listPartitionsReq);
System.out.println(partitionNames);

// Output:
// [_default]
```

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

### Create and List Partitions in Python

Source: https://docs.zilliz.com/docs/byoc/manage-partitions

Use the Milvus client to create a new partition and then list all partitions for a collection. Ensure the client is initialized before use.

```python
client.create_partition(
    collection_name="my_collection",
    partition_name="partitionA"
)

res = client.list_partitions(
    collection_name="my_collection"
)

print(res)

# Output
#
# ["_default", "partitionA"]
```

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

### Install PyMilvus Python SDK

Source: https://docs.zilliz.com/docs/byoc/install-sdks

Install the PyMilvus SDK compatible with Milvus v2.5.x. Ensure your Python version is 3.8 or higher. To install for Milvus v2.6.x, replace '2.5.18' with '2.6.9'.

```bash
python -m pip install pymilvus==2.5.18

# Update PyMilvus to the newest version
python -m pip install --upgrade pymilvus

# Verify installation success
python -m pip list | grep pymilvus
```

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

### Install pymilvus

Source: https://docs.zilliz.com/docs/byoc/use-bulkwriter

Install or upgrade the pymilvus library to the latest version using pip.

```bash
pip install --upgrade pymilvus
```

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

### Create Collection with Consistency Level (Go)

Source: https://docs.zilliz.com/docs/byoc/manage-collections-sdks

This Go example shows how to create a collection and set its consistency level using the Milvus Go SDK. Error handling is included for the creation process.

```go
err = client.CreateCollection(ctx, milvusclient.NewCreateCollectionOption("customized_setup_6", schema).
    WithConsistencyLevel(entity.ClBounded))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println("collection created")
```

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

### Create a Database (Go)

Source: https://docs.zilliz.com/docs/byoc/database

Use the Milvus Go SDK to create a database. The client requires a context, configuration with address, and an API key (token).

```go
cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "https://{cluster-id}.{region}.vectordb.zillizcloud.com:19530",
    APIKey: "YOUR_CLUSTER_TOKEN"
})
if err != nil {
    // handle err
}

err = cli.CreateDatabase(ctx, milvusclient.NewCreateDatabaseOption("my_database_1"))
if err != nil {
    // handle err
}
```

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

### Install Milvus Backup Tool

Source: https://docs.zilliz.com/docs/agents/zilliz-migration-prompts

Download and make the Milvus backup tool executable. This is the first step for migrating from Milvus via the backup tool.

```plaintext
# Download the latest release
wget https://github.com/zilliztech/milvus-backup/releases/latest/download/milvus-backup_Linux_x86_64.tar.gz
tar -xzf milvus-backup_Linux_x86_64.tar.gz
chmod +x milvus-backup
```

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

### JSON File Example

Source: https://docs.zilliz.com/docs/data-import-json

Example of data structured in a standard JSON array format for import.

```json
 [
     {"primary_key":89,"vector":[0.7857309327639853,0.6185684289533679]},
     {"primary_key":-22,"vector":[0.7227987733802379,0.6910585598920134]},
     {"primary_key":85,"vector":[0.7948503430666686,0.6068055142521362]}
 ]
```

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

### Install Required Libraries

Source: https://docs.zilliz.com/docs/byoc/minhash-lsh

Install the necessary Python packages for MinHash LSH and Zilliz Cloud integration.

```bash
pip install pymilvus datasketch numpy
```

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

### Export Data to File using QueryIterator (Python)

Source: https://docs.zilliz.com/docs/byoc/export-data-iterators

Demonstrates exporting data from the 'quick_setup' collection using the QueryIterator API and appending it to a file. Requires pymilvus library and connection details.

```python
import json
from pymilvus import connections, Collection

CLUSTER_ENDPOINT = "YOUR_CLUSTER_ENDPOINT"
TOKEN = "YOUR_CLUSTER_TOKEN"

connections.connect(
    uri=CLUSTER_ENDPOINT,
    token=TOKEN 
)

collection = Collection("quick_setup")

# 6. Query with iterator
```

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

### Create Database with Properties (Go)

Source: https://docs.zilliz.com/docs/byoc/database

Use the Milvus Go SDK to create a database and set properties like the replica number using the WithProperty option.

```go
err := cli.CreateDatabase(ctx, milvusclient.NewCreateDatabaseOption("my_database_2").WithProperty("database.replica.number", 3))
if err != nil {
    // handle err
}
```
Tokens:
Raw