Gerir colecções

from pymilvus import MilvusClient, DataType

# 1. Set up a Milvus client
client = MilvusClient(
    uri="http://localhost:19530"
)

# 2. Create a collection in quick setup mode
client.create_collection(
    collection_name="quick_setup",
    dimension=5
)

res = client.get_load_state(
    collection_name="quick_setup"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.collection.request.GetLoadStateReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

String CLUSTER_ENDPOINT = "http://localhost:19530";

// 1. Connect to Milvus server
ConnectConfig connectConfig = ConnectConfig.builder()
    .uri(CLUSTER_ENDPOINT)
    .build();

MilvusClientV2 client = new MilvusClientV2(connectConfig);

// 2. Create a collection in quick setup mode
CreateCollectionReq quickSetupReq = CreateCollectionReq.builder()
    .collectionName("quick_setup")
    .dimension(5)
    .build();

client.createCollection(quickSetupReq);

// Thread.sleep(5000);

GetLoadStateReq quickSetupLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .build();

Boolean res = client.getLoadState(quickSetupLoadStateReq);

System.out.println(res);

// Output:
// true

address = "http://localhost:19530"

// 1. Set up a Milvus Client
client = new MilvusClient({address});

// 2. Create a collection in quick setup mode
let res = await client.createCollection({
    collection_name: "quick_setup",
    dimension: 5,
});  

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.getLoadState({
    collection_name: "quick_setup"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

import (
  "context"
  "fmt"
  "log"
  "time"

  milvusClient "github.com/milvus-io/milvus-sdk-go/v2/client" // milvusClient is an alias for milvus client package
  "github.com/milvus-io/milvus-sdk-go/v2/entity"
)

func main() {
    ctx := context.Background()
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    // 1. Set up a Milvus client
    client, err := milvusClient.NewClient(ctx, milvusClient.Config{
        Address: "localhost:19530",
    })
    if err != nil {
        log.Fatal("failed to connect to milvus:", err.Error())
    }
    defer client.Close()
    
    // 2. Create a collection in quick setup mode
    err = client.NewCollection(ctx, "quick_setup", 5)
    if err != nil {
        log.Fatal("failed to create collection:", err.Error())
    }
    
    stateLoad, err := client.GetLoadState(context.Background(), "quick_setup", []string{})
    if err != nil {
        log.Fatal("failed to get load state:", err.Error())
    }
    fmt.Println(stateLoad)
    // Output
    // 3
    
    // LoadStateNotExist -> LoadState = 0
    // LoadStateNotLoad  -> LoadState = 1
    // LoadStateLoading  -> LoadState = 2
    // LoadStateLoaded   -> LoadState = 3
}

$ export MILVUS_URI="localhost:19530"

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/create" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "quick_setup",
  "dimension": 5
}'

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

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "quick_setup"
}'

# {
#     "code": 0,
#     "data": {
#         "loadProgress": 100,
#         "loadState": "LoadStateLoaded"
#     }
# }

# 3. Create a collection in customized setup mode

# 3.1. Create schema
schema = MilvusClient.create_schema(
    auto_id=False,
    enable_dynamic_field=True,
)

# 3.2. Add fields to schema
schema.add_field(field_name="my_id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="my_vector", datatype=DataType.FLOAT_VECTOR, dim=5)

import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

// 3. Create a collection in customized setup mode

// 3.1 Create schema
CreateCollectionReq.CollectionSchema schema = client.createSchema();

// 3.2 Add fields to schema
schema.addField(AddFieldReq.builder()
    .fieldName("my_id")
    .dataType(DataType.Int64)
    .isPrimaryKey(true)
    .autoID(false)
    .build());

schema.addField(AddFieldReq.builder()
    .fieldName("my_vector")
    .dataType(DataType.FloatVector)
    .dimension(5)
    .build());

// 3. Create a collection in customized setup mode
// 3.1 Define fields
const fields = [
    {
        name: "my_id",
        data_type: DataType.Int64,
        is_primary_key: true,
        auto_id: false
    },
    {
        name: "my_vector",
        data_type: DataType.FloatVector,
        dim: 5
    },
]

// 3. Create a collection in customized setup mode

// 3.1 Create schema
schema := entity.NewSchema()

// 3.2. Add fields to schema
schema.WithField(
    entity.NewField().
        WithName("my_id").
        WithDataType(entity.FieldTypeInt64).
        WithIsPrimaryKey(false).
        WithIsAutoID(true)).
    WithField(
        entity.NewField().
            WithName("my_vector").
            WithDataType(entity.FieldTypeFloatVector).
            WithDim(5))

export fields='[{ \
    "fieldName": "my_id", \
    "dataType": "Int64", \
    "isPrimary": true \
}, \
{ \
    "fieldName": "my_vector", \
    "dataType": "FloatVector", \
    "elementTypeParams": { \
        "dim": 5 \
    } \
}]'

Passo 2: Configurar parâmetros de índice

Os parâmetros de indexação ditam a forma como o Milvus organiza os seus dados dentro de uma coleção. Pode personalizar o processo de indexação para campos específicos, ajustando os seus metric_type e index_type. Para o campo vetorial, tem a flexibilidade de selecionar COSINE, L2, IP, HAMMING, ou JACCARD como metric_type, dependendo do tipo de vectores com que está a trabalhar. Para obter mais informações, consulte Métricas de similaridade.

# 3.3. Prepare index parameters
index_params = client.prepare_index_params()

# 3.4. Add indexes
index_params.add_index(
    field_name="my_id",
    index_type="STL_SORT"
)

index_params.add_index(
    field_name="my_vector", 
    index_type="IVF_FLAT",
    metric_type="IP",
    params={ "nlist": 128 }
)

import io.milvus.v2.common.IndexParam;

// 3.3 Prepare index parameters
IndexParam indexParamForIdField = IndexParam.builder()
    .fieldName("my_id")
    .indexType(IndexParam.IndexType.STL_SORT)
    .build();

IndexParam indexParamForVectorField = IndexParam.builder()
    .fieldName("my_vector")
    .indexType(IndexParam.IndexType.IVF_FLAT)
    .metricType(IndexParam.MetricType.L2)
    .extraParams(Map.of("nlist", 1024))
    .build();

List<IndexParam> indexParams = new ArrayList<>();
indexParams.add(indexParamForIdField);
indexParams.add(indexParamForVectorField);

// 3.2 Prepare index parameters
const index_params = [{
    field_name: "my_id",
    index_type: "STL_SORT"
},{
    field_name: "my_vector",
    index_type: "IVF_FLAT",
    metric_type: "IP",
    params: { nlist: 1024}
}]

// 3.3 Prepare index parameters
idxID := entity.NewScalarIndexWithType(entity.Sorted)

idxVector, err := entity.NewIndexIvfFlat(entity.IP, 1024)
if err != nil {
  log.Fatal("failed to new index:", err.Error())
}

export indexParams='[{ \
    "fieldName": "my_id", \
    "indexName": "my_id", \
    "params": { \
        "index_type": "SLT_SORT" \
  } \
}, { \
    "fieldName": "my_vector", \
    "metricType": "COSINE", \
    "indexName": "my_vector", \
    "params": { \
        "index_type": "IVF_FLAT", \
        "nlist": 1024 \
  } \
}]'

O fragmento de código acima demonstra como configurar os parâmetros de índice para o campo vetorial e um campo escalar, respetivamente. Para o campo vetorial, defina o tipo de métrica e o tipo de índice. Para um campo escalar, defina apenas o tipo de índice. Recomenda-se a criação de um índice para o campo vetorial e quaisquer campos escalares que sejam frequentemente utilizados para filtragem.

Passo 3: Criar a coleção

Tem a opção de criar uma coleção e um ficheiro de índice separadamente ou de criar uma coleção com o índice carregado simultaneamente na criação.

• Crie uma coleção com o índice carregado simultaneamente aquando da criação.

  Python JavaNode.jscURL

  # 3.5. Create a collection with the index loaded simultaneously
  client.create_collection(
      collection_name="customized_setup_1",
      schema=schema,
      index_params=index_params
  )
  
  time.sleep(5)
  
  res = client.get_load_state(
      collection_name="customized_setup_1"
  )
  
  print(res)
  
  # Output
  #
  # {
  #     "state": "<LoadState: Loaded>"
  # }
  

  import io.milvus.v2.service.collection.request.CreateCollectionReq;
  import io.milvus.v2.service.collection.request.GetLoadStateReq;
  
  // 3.4 Create a collection with schema and index parameters
  CreateCollectionReq customizedSetupReq1 = CreateCollectionReq.builder()
      .collectionName("customized_setup_1")
      .collectionSchema(schema)
      .indexParams(indexParams)
      .build();
  
  client.createCollection(customizedSetupReq1);
  
  // Thread.sleep(5000);
  
  // 3.5 Get load state of the collection
  GetLoadStateReq customSetupLoadStateReq1 = GetLoadStateReq.builder()
      .collectionName("customized_setup_1")
      .build();
  
  res = client.getLoadState(customSetupLoadStateReq1);
  
  System.out.println(res);
  
  // Output:
  // true
  

  // 3.3 Create a collection with fields and index parameters
  res = await client.createCollection({
      collection_name: "customized_setup_1",
      fields: fields,
      index_params: index_params,
  })
  
  console.log(res.error_code)  
  
  // Output
  // 
  // Success
  // 
  
  res = await client.getLoadState({
      collection_name: "customized_setup_1"
  })
  
  console.log(res.state)
  
  // Output
  // 
  // LoadStateLoaded
  //   
  

  $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/create" \
  -H "Content-Type: application/json" \
  -d '{
      "collectionName": "customized_setup_1",
      "schema": {
          "autoId": false,
          "enabledDynamicField": false,
          "fields": [
              {
                  "fieldName": "my_id",
                  "dataType": "Int64",
                  "isPrimary": true
              },
              {
                  "fieldName": "my_vector",
                  "dataType": "FloatVector",
                  "elementTypeParams": {
                      "dim": "5"
                  }
              }
          ]
      },
      "indexParams": [
          {
              "fieldName": "my_vector",
              "metricType": "COSINE",
              "indexName": "my_vector",
              "params": {
                  "index_type": "IVF_FLAT",
                  "nlist": "1024"
              }
          },
          {
              "fieldName": "my_id",
              "indexName": "my_id",
              "params": {
                  "index_type": "STL_SORT"
              }            
          }
      ]
  }'
  
  # Output
  #
  # {
  #     "code": 0,
  #     "data": {},
  # }
  
  $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
  -H "Content-Type: application/json" \
  -d '{
      "collectionName": "customized_setup_1"
  }'
  
  # {
  #     "code": 0,
  #     "data": {
  #         "loadProgress": 100,
  #         "loadState": "LoadStateLoaded"
  #     }
  # }
  

  A coleção criada acima é carregada automaticamente. Para saber mais sobre o carregamento e a libertação de uma coleção, consulte Carregar e libertar colecções.

• Crie uma coleção e um arquivo de índice separadamente.

  Python JavaNode.jsGocURL

  # 3.6. Create a collection and index it separately
  client.create_collection(
      collection_name="customized_setup_2",
      schema=schema,
  )
  
  res = client.get_load_state(
      collection_name="customized_setup_2"
  )
  
  print(res)
  
  # Output
  #
  # {
  #     "state": "<LoadState: NotLoad>"
  # }
  

  // 3.6 Create a collection and index it separately
  CreateCollectionReq customizedSetupReq2 = CreateCollectionReq.builder()
      .collectionName("customized_setup_2")
      .collectionSchema(schema)
      .build();
  
  client.createCollection(customizedSetupReq2);
  

  // 3.4 Create a collection and index it seperately
  res = await client.createCollection({
      collection_name: "customized_setup_2",
      fields: fields,
  })
  
  console.log(res.error_code)
  
  // Output
  // 
  // Success
  // 
  
  res = await client.getLoadState({
      collection_name: "customized_setup_2"
  })
  
  console.log(res.state)
  
  // Output
  // 
  // LoadStateNotLoad
  // 
  

  // 3.4 Create a collection and index it seperately
  schema.CollectionName = "customized_setup_2"
  client.CreateCollection(ctx, schema, entity.DefaultShardNumber)
  
  stateLoad, err := client.GetLoadState(context.Background(), "customized_setup_2", []string{})
  if err != nil {
      log.Fatal("failed to get load state:", err.Error())
  }
  fmt.Println(stateLoad)
  
  // Output
  // 1
  
  // LoadStateNotExist -> LoadState = 0
  // LoadStateNotLoad  -> LoadState = 1
  // LoadStateLoading  -> LoadState = 2
  // LoadStateLoaded   -> LoadState = 3
  

  $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/create" \
  -H "Content-Type: application/json" \
  -d '{
      "collectionName": "customized_setup_2",
      "schema": {
          "autoId": false,
          "enabledDynamicField": false,
          "fields": [
              {
                  "fieldName": "my_id",
                  "dataType": "Int64",
                  "isPrimary": true
              },
              {
                  "fieldName": "my_vector",
                  "dataType": "FloatVector",
                  "elementTypeParams": {
                      "dim": "5"
                  }
              }
          ]
          
      }
  }'
  
  # Output
  #
  # {
  #     "code": 0,
  #     "data": {},
  # }
  
  $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
  -H "Content-Type: application/json" \
  -d '{
      "collectionName": "customized_setup_2"
  }'
  
  # {
  #     "code": 0,
  #     "data": {
  #         "loadState": "LoadStateNotLoaded"
  #     }
  # }
  

  A coleção criada acima não é carregada automaticamente. Pode criar um índice para a coleção da seguinte forma. A criação de um índice para a coleção de uma forma separada não carrega automaticamente a coleção. Para obter detalhes, consulte Carregar e liberar coleção.

  Parâmetro	Descrição
  collection_name	O nome da coleção.
  schema	O esquema desta coleção. Se definir este parâmetro como None indica que esta coleção será criada com as definições por defeito. Para configurar uma coleção com um esquema personalizado, é necessário criar um objeto CollectionSchema e referenciá-lo aqui. Neste caso, o Milvus ignora todas as outras definições relacionadas com o esquema incluídas no pedido.
  index_params	Os parâmetros para construir o índice no campo vetorial desta coleção. Para configurar uma coleção com um esquema personalizado e carregar automaticamente a coleção para a memória, é necessário criar um objeto IndexParams e referenciá-lo aqui. Deve pelo menos adicionar um índice para o campo vetorial nesta coleção. Também pode ignorar este parâmetro se preferir configurar os parâmetros do índice mais tarde.

  Parâmetro	Descrição
  collectionName	O nome da coleção.
  collectionSchema	O esquema desta coleção. Se o deixar vazio, indica que esta coleção será criada com as predefinições. Para configurar uma coleção com um esquema personalizado, é necessário criar um objeto CollectionSchema e referenciá-lo aqui.
  indexParams	Os parâmetros para criar o índice no campo de vetor nesta coleção. Para configurar uma coleção com um esquema personalizado e carregar automaticamente a coleção para a memória, crie um objeto IndexParams com uma lista de objectos IndexParam e faça referência a este objeto aqui.

  Parâmetro	Descrição
  collection_name	O nome da coleção.
  fields	Os campos na coleção.
  index_params	Os parâmetros de índice para a coleção a criar.

  Parâmetro	Descrição
  schema.CollectionName	O nome da coleção.
  schema	O esquema desta coleção.
  index_params	Os parâmetros de índice para a coleção a criar.

  Parâmetro	Descrição
  collectionName	O nome da coleção.
  schema	O esquema é responsável pela organização dos dados na coleção de destino. Um esquema válido deve ter vários campos, que devem incluir uma chave primária, um campo vetorial e vários campos escalares.
  schema.autoID	Se permite que o campo primário seja incrementado automaticamente. Definir este valor como True faz com que o campo primário seja incrementado automaticamente. Neste caso, o campo primário não deve ser incluído nos dados a inserir para evitar erros. Defina este parâmetro no campo com is_primary definido como True.
  schema.enableDynamicField	Se permite utilizar o campo reservado $meta para guardar campos não definidos pelo esquema em pares de valores chave.
  fields	Uma lista de objectos de campo.
  fields.fieldName	O nome do campo a criar na coleção de destino.
  fields.dataType	O tipo de dados dos valores do campo.
  fields.isPrimary	Se o campo atual é o campo primário. Definir isto como True torna o campo atual o campo primário.
  fields.elementTypeParams	Parâmetros de campo extra.
  fields.elementTypeParams.dim	Um parâmetro opcional para campos FloatVector ou BinaryVector que determina a dimensão do vetor.

  A coleção criada acima não é carregada automaticamente. Pode criar um índice para a coleção da seguinte forma. A criação de um índice para a coleção de uma forma separada não carrega automaticamente a coleção. Para obter detalhes, consulte Carregar e liberar coleção.

  Python JavaNode.jsGocURL

  # 3.6 Create index
  client.create_index(
      collection_name="customized_setup_2",
      index_params=index_params
  )
  
  res = client.get_load_state(
      collection_name="customized_setup_2"
  )
  
  print(res)
  
  # Output
  #
  # {
  #     "state": "<LoadState: NotLoad>"
  # }
  

  CreateIndexReq  createIndexReq = CreateIndexReq.builder()
      .collectionName("customized_setup_2")
      .indexParams(indexParams)
      .build();
  
  client.createIndex(createIndexReq);
  
  // Thread.sleep(1000);
  
  // 3.7 Get load state of the collection
  GetLoadStateReq customSetupLoadStateReq2 = GetLoadStateReq.builder()
      .collectionName("customized_setup_2")
      .build();
  
  res = client.getLoadState(customSetupLoadStateReq2);
  
  System.out.println(res);
  
  // Output:
  // false
  

  // 3.5 Create index
  res = await client.createIndex({
      collection_name: "customized_setup_2",
      field_name: "my_vector",
      index_type: "IVF_FLAT",
      metric_type: "IP",
      params: { nlist: 1024}
  })
  
  res = await client.getLoadState({
      collection_name: "customized_setup_2"
  })
  
  console.log(res.state)
  
  // Output
  // 
  // LoadStateNotLoad
  //
  

  // 3.5 Create index
  client.CreateIndex(ctx, "customized_setup_2", "my_id", idxID, false)
  client.CreateIndex(ctx, "customized_setup_2", "my_vector", idxVector, false)
  
  stateLoad, err = client.GetLoadState(context.Background(), "customized_setup_2", []string{})
  if err != nil {
      log.Fatal("failed to get load state:", err.Error())
  }
  fmt.Println(stateLoad)
  // Output
  // 1
  
  // LoadStateNotExist -> LoadState = 0
  // LoadStateNotLoad  -> LoadState = 1
  // LoadStateLoading  -> LoadState = 2
  // LoadStateLoaded   -> LoadState = 3
  

  $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/indexes/create" \
  -H "Content-Type: application/json" \
  -d '{
      "collectionName": "customized_setup_2",
      "indexParams": [
          {
              "metricType": "L2",
              "fieldName": "my_vector",
              "indexName": "my_vector",
              "indexConfig": {
                  "index_type": "IVF_FLAT",
                  "nlist": "1024"
              }
          }
      ]
  }'
  
  # Output
  #
  # {
  #     "code": 0,
  #     "data": {},
  # }
  
  $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
  -H "Content-Type: application/json" \
  -d '{
      "collectionName": "customized_setup_2"
  }'
  
  # {
  #     "code": 0,
  #     "data": {
  #         "loadState": "LoadStateNotLoaded"
  #     }
  # }
  

  Parâmetro	Descrição da coleção
  collection_name	O nome da coleção.
  index_params	Um objeto IndexParams que contém uma lista de objectos IndexParam.

Visualizar colecções

# 5. View Collections
res = client.describe_collection(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "collection_name": "customized_setup_2",
#     "auto_id": false,
#     "num_shards": 1,
#     "description": "",
#     "fields": [
#         {
#             "field_id": 100,
#             "name": "my_id",
#             "description": "",
#             "type": 5,
#             "params": {},
#             "element_type": 0,
#             "is_primary": true
#         },
#         {
#             "field_id": 101,
#             "name": "my_vector",
#             "description": "",
#             "type": 101,
#             "params": {
#                 "dim": 5
#             },
#             "element_type": 0
#         }
#     ],
#     "aliases": [],
#     "collection_id": 448143479230158446,
#     "consistency_level": 2,
#     "properties": {},
#     "num_partitions": 1,
#     "enable_dynamic_field": true
# }

import io.milvus.v2.service.collection.request.DescribeCollectionReq;
import io.milvus.v2.service.collection.response.DescribeCollectionResp;

// 4. View collections
DescribeCollectionReq describeCollectionReq = DescribeCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

DescribeCollectionResp describeCollectionRes = client.describeCollection(describeCollectionReq);

System.out.println(JSONObject.toJSON(describeCollectionRes));

// Output:
// {
//     "createTime": 449005822816026627,
//     "collectionSchema": {"fieldSchemaList": [
//         {
//             "autoID": false,
//             "dataType": "Int64",
//             "name": "my_id",
//             "description": "",
//             "isPrimaryKey": true,
//             "maxLength": 65535,
//             "isPartitionKey": false
//         },
//         {
//             "autoID": false,
//             "dataType": "FloatVector",
//             "name": "my_vector",
//             "description": "",
//             "isPrimaryKey": false,
//             "dimension": 5,
//             "maxLength": 65535,
//             "isPartitionKey": false
//         }
//     ]},
//     "vectorFieldName": ["my_vector"],
//     "autoID": false,
//     "fieldNames": [
//         "my_id",
//         "my_vector"
//     ],
//     "description": "",
//     "numOfPartitions": 1,
//     "primaryFieldName": "my_id",
//     "enableDynamicField": true,
//     "collectionName": "customized_setup_2"
// }

// 5. View Collections
res = await client.describeCollection({
    collection_name: "customized_setup_2"
})

console.log(res)

// Output
// 
// {
//   virtual_channel_names: [ 'by-dev-rootcoord-dml_13_449007919953017716v0' ],
//   physical_channel_names: [ 'by-dev-rootcoord-dml_13' ],
//   aliases: [],
//   start_positions: [],
//   properties: [],
//   status: {
//     extra_info: {},
//     error_code: 'Success',
//     reason: '',
//     code: 0,
//     retriable: false,
//     detail: ''
//   },
//   schema: {
//     fields: [ [Object], [Object] ],
//     properties: [],
//     name: 'customized_setup_2',
//     description: '',
//     autoID: false,
//     enable_dynamic_field: false
//   },
//   collectionID: '449007919953017716',
//   created_timestamp: '449024569603784707',
//   created_utc_timestamp: '1712892797866',
//   shards_num: 1,
//   consistency_level: 'Bounded',
//   collection_name: 'customized_setup_2',
//   db_name: 'default',
//   num_partitions: '1'
// }
// 

// 4. View collections

res, err := client.DescribeCollection(ctx, "customized_setup_2")
if err != nil {
    log.Fatal("failed to describe collection:", err.Error())
}
fmt.Printf("ConsistencyLevel: %v\nID: %v\nLoaded: %v\nName: %v\nPhysicalChannels: %v\nProperties: %v\nSchemaField1: %v\nSchemaField2: %v\nShardNum: %v\nVirtualChannels: %v\nSchemaAutoID: %v\nSchemaCollectionName: %v\nSchemaDescription: %v",
    res.ConsistencyLevel, res.ID, res.Loaded, res.Name, res.PhysicalChannels,
    res.Properties, res.Schema.Fields[0], res.Schema.Fields[1], res.ShardNum,
    res.VirtualChannels, res.Schema.AutoID, res.Schema.CollectionName, res.Schema.Description)

// Output:
// ConsistencyLevel: 2
// ID: 453858520413977280
// Loaded: false
// Name: customized_setup_2
// PhysicalChannels: [by-dev-rootcoord-dml_14]
// Properties: map[]
// SchemaField1: &{100 my_id true false  int64 map[] map[] false false false undefined}
// SchemaField2: &{101 my_vector false false  []float32 map[dim:5] map[] false false false undefined}
// ShardNum: 1
// VirtualChannels: [by-dev-rootcoord-dml_14_453858520413977280v0]
// SchemaAutoID: false
// SchemaCollectionName: customized_setup_2
// SchemaDescription: 2024/11/12 14:06:53 my_rag_collection

curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/describe" \
-H "Content-Type: application/json" \
-d '{
    "dbName": "default",
    "collectionName": "test_collection"
}'

# {
#     "code": 0,
#     "data": {
#         "aliases": [],
#         "autoId": false,
#         "collectionID": 448707763883002014,
#         "collectionName": "test_collection",
#         "consistencyLevel": "Bounded",
#         "description": "",
#         "enableDynamicField": true,
#         "fields": [
#             {
#                 "autoId": false,
#                 "description": "",
#                 "id": 100,
#                 "name": "id",
#                 "partitionKey": false,
#                 "primaryKey": true,
#                 "type": "Int64"
#             },
#             {
#                 "autoId": false,
#                 "description": "",
#                 "id": 101,
#                 "name": "vector",
#                 "params": [
#                     {
#                         "key": "dim",
#                         "value": "5"
#                     }
#                 ],
#                 "partitionKey": false,
#                 "primaryKey": false,
#                 "type": "FloatVector"
#             }
#         ],
#         "indexes": [
#             {
#                 "fieldName": "vector",
#                 "indexName": "vector",
#                 "metricType": "COSINE"
#             }
#         ],
#         "load": "LoadStateLoaded",
#         "partitionsNum": 1,
#         "properties": [],
#         "shardsNum": 1
#     }
# }

Para listar todas as colecções existentes, pode fazer o seguinte:

# 6. List all collection names
res = client.list_collections()

print(res)

# Output
#
# [
#     "customized_setup_2",
#     "quick_setup",
#     "customized_setup_1"
# ]

import io.milvus.v2.service.collection.response.ListCollectionsResp;

// 5. List all collection names
ListCollectionsResp listCollectionsRes = client.listCollections();

System.out.println(listCollectionsRes.getCollectionNames());

// Output:
// [
//     "customized_setup_2",
//     "quick_setup",
//     "customized_setup_1"
// ]

// 5. List all collection names
ListCollectionsResp listCollectionsRes = client.listCollections();

System.out.println(listCollectionsRes.getCollectionNames());

// Output:
// [
//     "customized_setup_1",
//     "quick_setup",
//     "customized_setup_2"
// ]

// 5. List all collection names
collections, err := client.ListCollections(ctx)
if err != nil {
    log.Fatal("failed to list collection:", err.Error())
}
for _, c := range collections {
    log.Println(c.Name)
}

// Output:
// customized_setup_2
// quick_setup

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/list" \
-H "Content-Type: application/json" \
-d '{
    "dbName": "default"
}'

# {
#   "code": 0,
#   "data": [
#     "quick_setup",
#     "customized_setup_1",
#     "customized_setup_2"
#   ]
# }

Carregar e libertar uma coleção

Durante o processo de carregamento de uma coleção, o Milvus carrega o ficheiro de índice da coleção para a memória. Por outro lado, ao liberar uma coleção, Milvus descarrega o arquivo de índice da memória. Antes de efetuar pesquisas numa coleção, certifique-se de que a coleção está carregada.

Carregar uma coleção

# 7. Load the collection
client.load_collection(
    collection_name="customized_setup_2",
    replica_number=1 # Number of replicas to create on query nodes. Max value is 1 for Milvus Standalone, and no greater than `queryNode.replicas` for Milvus Cluster.
)

res = client.get_load_state(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }

import io.milvus.v2.service.collection.request.LoadCollectionReq;

// 6. Load the collection
LoadCollectionReq loadCollectionReq = LoadCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

client.loadCollection(loadCollectionReq);

// Thread.sleep(5000);

// 7. Get load state of the collection
GetLoadStateReq loadStateReq = GetLoadStateReq.builder()
    .collectionName("customized_setup_2")
    .build();

res = client.getLoadState(loadStateReq);

System.out.println(res);

// Output:
// true

// 7. Load the collection
res = await client.loadCollection({
    collection_name: "customized_setup_2"
})

console.log(res.error_code)

// Output
// 
// Success
// 

await sleep(3000)

res = await client.getLoadState({
    collection_name: "customized_setup_2"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

// 6. Load the collection

err = client.LoadCollection(ctx, "customized_setup_2", false)
if err != nil {
    log.Fatal("failed to laod collection:", err.Error())
}

// 7. Get load state of the collection
stateLoad, err := client.GetLoadState(context.Background(), "customized_setup_2", []string{})
if err != nil {
    log.Fatal("failed to get load state:", err.Error())
}
fmt.Println(stateLoad)

// Output:
// 3

// LoadStateNotExist -> LoadState = 0
// LoadStateNotLoad  -> LoadState = 1
// LoadStateLoading  -> LoadState = 2
// LoadStateLoaded   -> LoadState = 3

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/load" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'

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

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "customized_setup_2"
}'

# {
#     "code": 0,
#     "data": {
#         "loadProgress": 100,
#         "loadState": "LoadStateLoaded"
#     }
# }

Carregar uma coleção parcialmente (Pré-visualização pública)

Ao receber o seu pedido de carregamento, o Milvus carrega todos os índices dos campos vectoriais e todos os dados dos campos escalares para a memória. Se alguns campos não estiverem envolvidos em pesquisas e consultas, pode excluí-los do carregamento para reduzir a utilização da memória, melhorando o desempenho da pesquisa.

# 7. Load the collection
client.load_collection(
    collection_name="customized_setup_2",
    load_fields=["my_id", "my_vector"], # Load only the specified fields
    skip_load_dynamic_field=True # Skip loading the dynamic field
)

res = client.get_load_state(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }

Libertar uma coleção

# 8. Release the collection
client.release_collection(
    collection_name="customized_setup_2"
)

res = client.get_load_state(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: NotLoad>"
# }

import io.milvus.v2.service.collection.request.ReleaseCollectionReq;

// 8. Release the collection
ReleaseCollectionReq releaseCollectionReq = ReleaseCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

client.releaseCollection(releaseCollectionReq);

// Thread.sleep(1000);

res = client.getLoadState(loadStateReq);

System.out.println(res);

// Output:
// false

// 8. Release the collection
res = await client.releaseCollection({
    collection_name: "customized_setup_2"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.getLoadState({
    collection_name: "customized_setup_2"
})

console.log(res.state)

// Output
// 
// LoadStateNotLoad
// 

// 8. Release the collection
errRelease := client.ReleaseCollection(context.Background(), "customized_setup_2")
if errRelease != nil {
    log.Fatal("failed to release collection:", errRelease.Error())
}
fmt.Println(errRelease)
stateLoad, err = client.GetLoadState(context.Background(), "customized_setup_2", []string{})
if err != nil {
    log.Fatal("failed to get load state:", err.Error())
}
fmt.Println(stateLoad)

// Output:
// 1

// meaning not loaded

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/release" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'

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


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "customized_setup_2"
}'


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

Configurar pseudónimos

Pode atribuir pseudónimos às colecções para as tornar mais significativas num contexto específico. É possível atribuir vários pseudónimos a uma coleção, mas não é possível partilhar um pseudónimo com várias colecções.

Criar aliases

# 9.1. Create aliases
client.create_alias(
    collection_name="customized_setup_2",
    alias="bob"
)

client.create_alias(
    collection_name="customized_setup_2",
    alias="alice"
)

import io.milvus.v2.service.utility.request.CreateAliasReq;

// 9. Manage aliases

// 9.1 Create alias
CreateAliasReq createAliasReq = CreateAliasReq.builder()
    .collectionName("customized_setup_2")
    .alias("bob")
    .build();

client.createAlias(createAliasReq);

createAliasReq = CreateAliasReq.builder()
    .collectionName("customized_setup_2")
    .alias("alice")
    .build();

client.createAlias(createAliasReq);

// 9. Manage aliases
// 9.1 Create aliases
res = await client.createAlias({
    collection_name: "customized_setup_2",
    alias: "bob"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.createAlias({
    collection_name: "customized_setup_2",
    alias: "alice"
})

console.log(res.error_code)

// Output
// 
// Success
// 

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/create" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2",
    "aliasName": "bob"
}'

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

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/create" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2",
    "aliasName": "alice"
}'

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

Listar aliases

# 9.2. List aliases
res = client.list_aliases(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "aliases": [
#         "bob",
#         "alice"
#     ],
#     "collection_name": "customized_setup_2",
#     "db_name": "default"
# }

import io.milvus.v2.service.utility.request.ListAliasesReq;
import io.milvus.v2.service.utility.response.ListAliasResp;

// 9.2 List alises
ListAliasesReq listAliasesReq = ListAliasesReq.builder()
    .collectionName("customized_setup_2")
    .build();

ListAliasResp listAliasRes = client.listAliases(listAliasesReq);

System.out.println(listAliasRes.getAlias());

// Output:
// [
//     "bob",
//     "alice"
// ]

// 9.2 List aliases
res = await client.listAliases({
    collection_name: "customized_setup_2"
})

console.log(res.aliases)

// Output
// 
// [ 'bob', 'alice' ]
// 

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/list" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'

# {
#     "code": 0,
#     "data": [
#         "bob",
#         "alice"
#     ]
# }

Descrever pseudónimos

# 9.3. Describe aliases
res = client.describe_alias(
    alias="bob"
)

print(res)

# Output
#
# {
#     "alias": "bob",
#     "collection_name": "customized_setup_2",
#     "db_name": "default"
# }

import io.milvus.v2.service.utility.request.DescribeAliasReq;
import io.milvus.v2.service.utility.response.DescribeAliasResp;

// 9.3 Describe alias
DescribeAliasReq describeAliasReq = DescribeAliasReq.builder()
    .alias("bob")
    .build();

DescribeAliasResp describeAliasRes = client.describeAlias(describeAliasReq);

System.out.println(JSONObject.toJSON(describeAliasRes));

// Output:
// {
//     "alias": "bob",
//     "collectionName": "customized_setup_2"
// }

// 9.3 Describe aliases
res = await client.describeAlias({
    collection_name: "customized_setup_2",
    alias: "bob"
})

console.log(res)

// Output
// 
// {
//   status: {
//     extra_info: {},
//     error_code: 'Success',
//     reason: '',
//     code: 0,
//     retriable: false,
//     detail: ''
//   },
//   db_name: 'default',
//   alias: 'bob',
//   collection: 'customized_setup_2'
// }
// 

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/describe" \
-H "Content-Type: application/json" \
-d '{
    "aliasName": "bob"
}'

# {
#     "code": 0,
#     "data": {
#         "aliasName": "bob",
#         "collectionName": "quick_setup",
#         "dbName": "default"
#     }
# }

Reatribuir aliases

# 9.4 Reassign aliases to other collections
client.alter_alias(
    collection_name="customized_setup_1",
    alias="alice"
)

res = client.list_aliases(
    collection_name="customized_setup_1"
)

print(res)

# Output
#
# {
#     "aliases": [
#         "alice"
#     ],
#     "collection_name": "customized_setup_1",
#     "db_name": "default"
# }

res = client.list_aliases(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "aliases": [
#         "bob"
#     ],
#     "collection_name": "customized_setup_2",
#     "db_name": "default"
# }

import io.milvus.v2.service.utility.request.AlterAliasReq;

// 9.4 Reassign alias to other collections
AlterAliasReq alterAliasReq = AlterAliasReq.builder()
    .collectionName("customized_setup_1")
    .alias("alice")
    .build();

client.alterAlias(alterAliasReq);

listAliasesReq = ListAliasesReq.builder()
    .collectionName("customized_setup_1")
    .build();

listAliasRes = client.listAliases(listAliasesReq);

System.out.println(listAliasRes.getAlias());

// Output:
// ["alice"]

listAliasesReq = ListAliasesReq.builder()
    .collectionName("customized_setup_2")
    .build();

listAliasRes = client.listAliases(listAliasesReq);

System.out.println(listAliasRes.getAlias());

// Output:
// ["bob"]

// 9.4 Reassign aliases to other collections
res = await client.alterAlias({
    collection_name: "customized_setup_1",
    alias: "alice"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.listAliases({
    collection_name: "customized_setup_1"
})

console.log(res.aliases)

// Output
// 
// [ 'alice' ]
// 

res = await client.listAliases({
    collection_name: "customized_setup_2"
})

console.log(res.aliases)

// Output
// 
// [ 'bob' ]
// 

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/alter" \
-H "Content-Type: application/json" \
-d '{
     "collectionName": "customized_setup_1",
     "aliasName": "alice"
}'

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


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/list" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_1"
}'


# {
#     "code": 0,
#     "data": [
#         "alice"
#     ]
# }


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/list" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'


# {
#     "code": 0,
#     "data": [
#         "bob"
#     ]
# }

Eliminar pseudónimos

# 9.5 Drop aliases
client.drop_alias(
    alias="bob"
)

client.drop_alias(
    alias="alice"
)

import io.milvus.v2.service.utility.request.DropAliasReq;

// 9.5 Drop alias
DropAliasReq dropAliasReq = DropAliasReq.builder()
    .alias("bob")
    .build();

client.dropAlias(dropAliasReq);

dropAliasReq = DropAliasReq.builder()
    .alias("alice")
    .build();

client.dropAlias(dropAliasReq);

// 9.5 Drop aliases
res = await client.dropAlias({
    alias: "bob"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.dropAlias({
    alias: "alice"
})

console.log(res.error_code)

// Output
// 
// Success
// 

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/drop" \
-H "Content-Type: application/json" \
-d '{
    "aliasName": "bob"
}'

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


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/drop" \
-H "Content-Type: application/json" \
-d '{
    "aliasName": "alice"
}'


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

Definir propriedades

É possível definir propriedades para uma coleção, tais como ttl.seconds e mmap.enabled. Para obter mais informações, consulte set_properties().

Definir TTL

Define o Time-To-Live (TTL) para os dados na coleção, o que especifica quanto tempo os dados devem ser retidos antes de serem automaticamente eliminados.

from pymilvus import Collection, connections

# Connect to Milvus server
connections.connect(host="localhost", port="19530") # Change to your Milvus server IP and port

# Get existing collection
collection = Collection("quick_setup")

# Set the TTL for the data in the collection
collection.set_properties(
    properties={
        "collection.ttl.seconds": 60
    }
)

Definir MMAP

Configure a propriedade de mapeamento de memória (MMAP) para a coleção, que determina se os dados são mapeados na memória para melhorar o desempenho da consulta. Para obter mais informações, consulte Configurar mapeamento de memória.

from pymilvus import Collection, connections

# Connect to Milvus server
connections.connect(host="localhost", port="19530") # Change to your Milvus server IP and port

# Get existing collection
collection = Collection("quick_setup")

# Before setting memory mapping property, we need to release the collection first.
collection.release()

# Set memory mapping property to True or Flase
collection.set_properties(
    properties={
        "mmap.enabled": True
    }
)

Abandonar uma coleção

Se uma coleção já não for necessária, pode abandoná-la.

# 10. Drop the collections
client.drop_collection(
    collection_name="quick_setup"
)

client.drop_collection(
    collection_name="customized_setup_1"
)

client.drop_collection(
    collection_name="customized_setup_2"
)

import io.milvus.v2.service.collection.request.DropCollectionReq;

// 10. Drop collections

DropCollectionReq dropQuickSetupParam = DropCollectionReq.builder()
    .collectionName("quick_setup")
    .build();

client.dropCollection(dropQuickSetupParam);

DropCollectionReq dropCustomizedSetupParam = DropCollectionReq.builder()
    .collectionName("customized_setup_1")
    .build();

client.dropCollection(dropCustomizedSetupParam);

dropCustomizedSetupParam = DropCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

client.dropCollection(dropCustomizedSetupParam);

// 10. Drop the collection
res = await client.dropCollection({
    collection_name: "customized_setup_2"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.dropCollection({
    collection_name: "customized_setup_1"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.dropCollection({
    collection_name: "quick_setup"
})

console.log(res.error_code)

// Output
// 
// Success
// 

// 10. Drop collections

err = client.DropCollection(ctx, "quick_setup")
if err != nil {
    log.Fatal("failed to drop collection:", err.Error())
}
err = client.DropCollection(ctx, "customized_setup_2")
if err != nil {
    log.Fatal("failed to drop collection:", err.Error())
}

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/drop" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "quick_setup"
}'

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


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/drop" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_1"
}'


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


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/drop" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'


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