Gestionar colecciones

Esta guía le guiará a través de la creación y gestión de colecciones utilizando el SDK de su elección.

Antes de empezar

• Ha instalado Milvus standalone o Milvus cluster.

• Ha instalado los SDK preferidos. Puede elegir entre varios lenguajes, incluyendo Python, Java, Go y Node.js.

Visión general

En Milvus, usted almacena sus incrustaciones vectoriales en colecciones. Todas las incrustaciones vectoriales dentro de una colección comparten la misma dimensionalidad y métrica de distancia para medir la similitud.

Las colecciones Milvus soportan campos dinámicos (es decir, campos no predefinidos en el esquema) e incremento automático de claves primarias.

Para adaptarse a las distintas preferencias, Milvus ofrece dos métodos para crear una colección. Uno proporciona una configuración rápida, mientras que el otro permite una personalización detallada del esquema de la colección y de los parámetros del índice.

Además, puede ver, cargar, liberar y soltar una colección cuando sea necesario.

Crear colección

Puede crear una colección de cualquiera de las siguientes maneras:

• Configuración rápida

  De esta manera, puede crear una colección simplemente dándole un nombre y especificando el número de dimensiones de las incrustaciones vectoriales que se almacenarán en esta colección. Para más detalles, consulte Configuración rápida.

• Configuración personalizada

  En lugar de dejar que In Milvus decida casi todo para su colección, puede determinar el esquema y los parámetros de índice de la colección por su cuenta. Para obtener más información, consulte Configuración personalizada.

Configuración rápida

Con el gran salto en la industria de la IA como telón de fondo, la mayoría de los desarrolladores sólo necesitan una colección sencilla pero dinámica para empezar. Milvus permite una configuración rápida de dicha colección con sólo tres argumentos:

• Nombre de la colección a crear,

• Dimensión de las incrustaciones vectoriales a insertar, y

• Tipo de métrica utilizada para medir las similitudes entre las incrustaciones vectoriales.

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
// 

$ 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"
#     }
# }

La colección generada en el código anterior contiene sólo dos campos: id (como clave primaria) y vector (como campo vectorial), con las opciones auto_id y enable_dynamic_field activadas por defecto.

• auto_id

  Activar esta configuración garantiza que la clave primaria se incremente automáticamente. No es necesario proporcionar manualmente claves primarias durante la inserción de datos.

• enable_dynamic_field

  Cuando está activada, todos los campos, excepto id y vector en los datos que se van a insertar, se tratan como campos dinámicos. Estos campos adicionales se guardan como pares clave-valor dentro de un campo especial denominado $meta. Esta función permite incluir campos adicionales durante la inserción de datos.

La colección indexada y cargada automáticamente a partir del código proporcionado está lista para la inserción inmediata de datos.

Configuración personalizada

En lugar de dejar que Milvus decida casi todo para su colección, puede determinar el esquema y los parámetros de indexación de la colección por su cuenta.

Paso 1: Configurar el esquema

Un esquema define la estructura de una colección. Dentro del esquema, tiene la opción de activar o desactivar enable_dynamic_field, añadir campos predefinidos y establecer atributos para cada campo. Para obtener una explicación detallada del concepto y de los tipos de datos disponibles, consulte Explicación del esquema.

# 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
    },
]

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

Paso 2: Configurar parámetros de índice

Los parámetros de índice dictan cómo Milvus organiza sus datos dentro de una colección. Puede adaptar el proceso de indexación para campos específicos ajustando sus metric_type y index_type. Para el campo vectorial, tiene la flexibilidad de seleccionar COSINE, L2, IP, HAMMING, o JACCARD como metric_type, dependiendo del tipo de vectores con los que esté trabajando. Para más información, consulte Métricas de similitud.

# 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}
}]

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 \
  } \
}]'

El fragmento de código anterior muestra cómo configurar los parámetros de índice para un campo vectorial y un campo escalar, respectivamente. Para el campo vectorial, establezca tanto el tipo métrico como el tipo de índice. Para un campo escalar, establezca sólo el tipo de índice. Se recomienda crear un índice para el campo vectorial y cualquier campo escalar que se utilice con frecuencia para filtrar.

Paso 3: Crear la colección

Tiene la opción de crear una colección y un archivo de índice por separado o crear una colección con el índice cargado simultáneamente en el momento de la creación.

• Crear una colección con el índice cargado simultáneamente a la creación.

  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"
  #     }
  # }
  

  La colección creada anteriormente se carga automáticamente. Para obtener más información sobre cómo cargar y liberar una colección, consulte Cargar y liberar colección.

• Cree una colección y un archivo de índice por separado.

  Python JavaNode.jscURL

  # 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
  // 
  

  $ 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"
  #     }
  # }
  

  La colección creada anteriormente no se carga automáticamente. Puede crear un índice para la colección de la siguiente manera. La creación de un índice para la colección de forma independiente no carga automáticamente la colección. Para más detalles, consulte Cargar y liberar colección.

  Parámetro	Descripción
  collection_name	El nombre de la colección.
  schema	El esquema de esta colección. Establecerlo como Ninguno indica que esta colección se creará con la configuración predeterminada. Para configurar una colección con un esquema personalizado, debe crear un objeto CollectionSchema y referenciarlo aquí. En este caso, Milvus ignora todos los demás parámetros relacionados con el esquema que se incluyen en la solicitud.
  index_params	Los parámetros para construir el índice sobre el campo vectorial en esta colección. Para configurar una colección con un esquema personalizado y cargar automáticamente la colección en memoria, necesita crear un objeto IndexParams y referenciarlo aquí. Debería añadir al menos un índice para el campo vectorial en esta colección. También puedes omitir este parámetro si prefieres configurar los parámetros del índice más adelante.

  Parámetro	Descripción
  collectionName	El nombre de la colección.
  collectionSchema	El esquema de esta colección. Dejarlo vacío indica que esta colección se creará con la configuración por defecto. Para configurar una colección con un esquema personalizado, debe crear un objeto CollectionSchema y referenciarlo aquí.
  indexParams	Los parámetros para construir el índice sobre el campo vectorial en esta colección. Para configurar una colección con un esquema personalizado y cargar automáticamente la colección en memoria, cree un objeto IndexParams con una lista de objetos IndexParam y haga referencia a él aquí.

  Parámetro	Descripción
  collection_name	El nombre de la colección.
  fields	Los campos de la colección.
  index_params	Los parámetros de índice de la colección a crear.

  Parámetro	Descripción
  collectionName	El nombre de la colección.
  schema	El esquema se encarga de organizar los datos en la colección de destino. Un esquema válido debe tener múltiples campos, que deben incluir una clave primaria, un campo vectorial y varios campos escalares.
  schema.autoID	Si permite que el campo primario se incremente automáticamente. Si se establece en True, el campo primario se incrementa automáticamente. En este caso, el campo primario no debe incluirse en los datos a insertar para evitar errores. Establezca este parámetro en el campo con is_primary a True.
  schema.enableDynamicField	Si permite utilizar el campo reservado $meta para contener campos no definidos por el esquema en pares clave-valor.
  fields	Una lista de objetos de campo.
  fields.fieldName	El nombre del campo a crear en la colección de destino.
  fields.dataType	El tipo de datos de los valores del campo.
  fields.isPrimary	Si el campo actual es el campo primario. Si se establece en True, el campo actual será el campo primario.
  fields.elementTypeParams	Parámetros de campo adicionales.
  fields.elementTypeParams.dim	Un parámetro opcional para los campos FloatVector o BinaryVector que determina la dimensión del vector.

  La colección creada anteriormente no se carga automáticamente. Puede crear un índice para la colección de la siguiente manera. La creación de un índice para la colección de forma independiente no carga automáticamente la colección. Para más detalles, consulte Cargar y liberar colección.

  Python JavaNode.jscURL

  # 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
  //
  

  $ 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	Descripción
  collection_name	El nombre de la colección.
  index_params	Un objeto IndexParams que contiene una lista de objetos IndexParam.

Ver colecciones

# 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'
// }
// 

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 las colecciones existentes, puedes hacer lo siguiente:

# 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"
// ]

$ 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"
#   ]
# }

Cargar y liberar colección

Durante el proceso de carga de una colección, Milvus carga el fichero índice de la colección en memoria. A la inversa, al liberar una colección, Milvus descarga el fichero índice de la memoria. Antes de realizar búsquedas en una colección, asegúrese de que la colección está cargada.

Cargar una colección

# 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
// 

$ 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"
#     }
# }

Cargar una colección parcialmente (Vista previa pública)

Al recibir su solicitud de carga, Milvus carga en memoria todos los índices de los campos vectoriales y todos los datos de los campos escalares. Si algunos campos no van a estar implicados en búsquedas y consultas, puede excluirlos de la carga para reducir el uso de memoria, mejorando el rendimiento de la búsqueda.

# 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>"
# }

Liberar una colección

# 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
// 

$ 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"
#     }
# }

Establecer alias

Puede asignar alias a las colecciones para que tengan más sentido en un contexto específico. Puede asignar varios alias a una colección, pero varias colecciones no pueden compartir un alias.

Crear alias

# 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": {}
# }

Lista de alias

# 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"
#     ]
# }

Describir alias

# 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"
#     }
# }

Reasignar alias

# 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 alias

# 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": {}
# }

Establecer propiedades

Puede establecer propiedades para una colección, como ttl.seconds y mmap.enabled. Para más información, consulte set_properties().

Establecer TTL

Establece el tiempo de vida (TTL) para los datos de la colección, que especifica cuánto tiempo deben conservarse los datos antes de que se eliminen automáticamente.

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
    }
)

Establecer MMAP

Configure la propiedad de asignación de memoria (MMAP) para la colección, que determina si los datos se asignan a la memoria para mejorar el rendimiento de la consulta. Para obtener más información, consulte Configurar la asignación de memoria.

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 una colecta

Si una colección ya no es necesaria, puede eliminarla.

# 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
// 

$ 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": {}
# }