Gestire le raccolte

Questa guida spiega come creare e gestire le raccolte utilizzando l'SDK di vostra scelta.

Prima di iniziare

• Avete installato Milvus standalone o Milvus cluster.

• Avete installato gli SDK preferiti. È possibile scegliere tra vari linguaggi, tra cui Python, Java, Go e Node.js.

Panoramica

In Milvus, si memorizzano le incorporazioni vettoriali in collezioni. Tutti gli embeddings vettoriali all'interno di una collezione condividono la stessa dimensionalità e la stessa metrica di distanza per misurare la somiglianza.

Le collezioni di Milvus supportano campi dinamici (cioè campi non predefiniti nello schema) e l'incremento automatico delle chiavi primarie.

Per soddisfare le diverse preferenze, Milvus offre due metodi per creare una collezione. Uno fornisce una configurazione rapida, mentre l'altro consente una personalizzazione dettagliata dello schema della collezione e dei parametri degli indici.

Inoltre, è possibile visualizzare, caricare, rilasciare e abbandonare una raccolta quando necessario.

Creare una raccolta

È possibile creare una raccolta in uno dei seguenti modi:

• Impostazione rapida

  In questo modo, è possibile creare una collezione semplicemente dandole un nome e specificando il numero di dimensioni delle incorporazioni vettoriali da memorizzare in questa collezione. Per ulteriori informazioni, consultare la sezione Impostazione rapida.

• Configurazione personalizzata

  Invece di lasciare che In Milvus decida quasi tutto per la vostra collezione, potete determinare da soli i parametri dello schema e dell'indice della collezione. Per maggiori dettagli, consultare la sezione Configurazione personalizzata.

Configurazione rapida

Nel contesto del grande balzo dell'industria dell'intelligenza artificiale, la maggior parte degli sviluppatori ha bisogno di una collezione semplice ma dinamica per iniziare. Milvus permette di configurare rapidamente una collezione di questo tipo con soli tre argomenti:

• Nome della collezione da creare,

• Dimensione delle incorporazioni vettoriali da inserire e

• Tipo di metrica utilizzata per misurare le somiglianze tra gli embeddings vettoriali.

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

L'insieme generato nel codice precedente contiene solo due campi: id (come chiave primaria) e vector (come campo vettore), con le impostazioni auto_id e enable_dynamic_field abilitate per default.

• auto_id

  L'attivazione di questa impostazione fa sì che la chiave primaria si incrementi automaticamente. Non è necessario fornire manualmente le chiavi primarie durante l'inserimento dei dati.

• enable_dynamic_field

  Quando è abilitata, tutti i campi, esclusi id e vector nei dati da inserire, sono trattati come campi dinamici. Questi campi aggiuntivi vengono salvati come coppie chiave-valore all'interno di un campo speciale denominato $meta. Questa funzione consente di includere campi aggiuntivi durante l'inserimento dei dati.

La collezione indicizzata e caricata automaticamente dal codice fornito è pronta per l'inserimento immediato dei dati.

Configurazione personalizzata

Invece di lasciare che Milvus decida quasi tutto per la vostra collezione, potete determinare da soli i parametri dello schema e dell'indice della collezione.

Passo 1: Impostazione dello schema

Uno schema definisce la struttura di una collezione. All'interno dello schema, si ha la possibilità di abilitare o disabilitare enable_dynamic_field, aggiungere campi predefiniti e impostare attributi per ogni campo. Per una spiegazione dettagliata del concetto e dei tipi di dati disponibili, consultare Schema spiegato.

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

Passo 2: Impostazione dei parametri di indice

I parametri di indice determinano il modo in cui Milvus organizza i dati all'interno di una collezione. È possibile personalizzare il processo di indicizzazione per campi specifici regolando i loro metric_type e index_type. Per il campo vettoriale, è possibile selezionare COSINE, L2, IP, HAMMING, o JACCARD come metric_type, a seconda del tipo di vettori con cui si lavora. Per ulteriori informazioni, consultare Metriche di somiglianza.

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

Il frammento di codice qui sopra mostra come impostare i parametri dell'indice rispettivamente per un campo vettoriale e per un campo scalare. Per il campo vettoriale, impostare sia il tipo di metrica che il tipo di indice. Per un campo scalare, impostare solo il tipo di indice. Si consiglia di creare un indice per il campo vettoriale e per tutti i campi scalari che vengono utilizzati frequentemente per il filtraggio.

Passo 3: Creare l'insieme

Si può scegliere di creare una collezione e un file indice separatamente o di creare una collezione con l'indice caricato contemporaneamente alla creazione.

• Creare una collezione con l'indice caricato contemporaneamente alla creazione.

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

  L'insieme creato in precedenza viene caricato automaticamente. Per ulteriori informazioni sul caricamento e il rilascio di una raccolta, consultare Carica e rilascia una raccolta.

• Creare una raccolta e un file di indice separatamente.

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

  L'insieme creato sopra non viene caricato automaticamente. È possibile creare un indice per la raccolta come segue. La creazione di un indice per la raccolta in modo separato non carica automaticamente la raccolta. Per ulteriori informazioni, consultare la sezione Caricare e rilasciare la raccolta.

  Parametro	Descrizione
  collection_name	Il nome della raccolta.
  schema	Lo schema di questa raccolta. Impostando questo valore a Nessuno, la raccolta verrà creata con le impostazioni predefinite. Per impostare una raccolta con uno schema personalizzato, è necessario creare un oggetto CollectionSchema e fare riferimento a questo oggetto. In questo caso, Milvus ignora tutte le altre impostazioni relative allo schema contenute nella richiesta.
  index_params	I parametri per costruire l'indice sul campo vettoriale di questa collezione. Per impostare una collezione con uno schema personalizzato e caricare automaticamente la collezione in memoria, è necessario creare un oggetto IndexParams e fare riferimento qui. È necessario aggiungere almeno un indice per il campo vettoriale di questa collezione. Si può anche saltare questo parametro se si preferisce impostare i parametri dell'indice in un secondo momento.

  Parametro	Descrizione
  collectionName	Il nome della collezione.
  collectionSchema	Lo schema di questa raccolta. Se lo si lascia vuoto, significa che la raccolta verrà creata con le impostazioni predefinite. Per impostare un insieme con uno schema personalizzato, è necessario creare un oggetto CollectionSchema e fare riferimento ad esso.
  indexParams	I parametri per costruire l'indice sul campo vettoriale di questa collezione. Per impostare una collezione con uno schema personalizzato e caricare automaticamente la collezione in memoria, creare un oggetto IndexParams con un elenco di oggetti IndexParam e fare riferimento qui.

  Parametro	Descrizione
  collection_name	Il nome dell'insieme.
  fields	I campi della collezione.
  index_params	I parametri dell'indice per la collezione da creare.

  Parametro	Descrizione
  collectionName	Il nome della raccolta.
  schema	Lo schema è responsabile dell'organizzazione dei dati nella raccolta di destinazione. Uno schema valido deve avere più campi, che devono includere una chiave primaria, un campo vettore e diversi campi scalari.
  schema.autoID	Se permette al campo primario di incrementarsi automaticamente. Impostando True, il campo primario si incrementa automaticamente. In questo caso, il campo primario non dovrebbe essere incluso nei dati da inserire per evitare errori. Impostare questo parametro nel campo con is_primary impostato su True.
  schema.enableDynamicField	Se permette di usare il campo riservato $meta per contenere campi non definiti dallo schema in coppie chiave-valore.
  fields	Un elenco di oggetti campo.
  fields.fieldName	Il nome del campo da creare nell'insieme di destinazione.
  fields.dataType	Il tipo di dati dei valori del campo.
  fields.isPrimary	Se il campo corrente è il campo primario. Impostando True, il campo corrente diventa il campo primario.
  fields.elementTypeParams	Parametri extra del campo.
  fields.elementTypeParams.dim	Un parametro opzionale per i campi FloatVector o BinaryVector che determina la dimensione del vettore.

  L'insieme creato sopra non viene caricato automaticamente. È possibile creare un indice per l'insieme come segue. La creazione di un indice per l'insieme in modo separato non carica automaticamente l'insieme. Per ulteriori informazioni, consultare la sezione Caricare e rilasciare l'insieme.

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

  Parametro	Descrizione
  collection_name	Il nome della collezione.
  index_params	Un oggetto IndexParams contenente un elenco di oggetti IndexParam.

Visualizzare le raccolte

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

Per elencare tutte le collezioni esistenti, si può procedere come segue:

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

Caricamento e rilascio della raccolta

Durante il processo di caricamento di una raccolta, Milvus carica in memoria il file di indice della raccolta. Al contrario, quando si rilascia una raccolta, Milvus scarica il file di indice dalla memoria. Prima di effettuare ricerche in una collezione, assicurarsi che la collezione sia caricata.

Caricare una collezione

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

Caricare parzialmente una raccolta (anteprima pubblica)

Quando riceve la richiesta di caricamento, Milvus carica in memoria tutti gli indici dei campi vettoriali e tutti i dati dei campi scalari. Se alcuni campi non devono essere coinvolti nelle ricerche e nelle query, è possibile escluderli dal caricamento per ridurre l'utilizzo della memoria, migliorando le prestazioni della ricerca.

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

Rilasciare una raccolta

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

Impostare gli alias

È possibile assegnare alias alle raccolte per renderle più significative in un contesto specifico. È possibile assegnare più alias a una raccolta, ma più raccolte non possono condividere un alias.

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

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

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

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

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

Impostare le proprietà

È possibile impostare le proprietà di un insieme, come ttl.seconds e mmap.enabled. Per ulteriori informazioni, consultare set_properties().

Imposta TTL

Imposta il Time-To-Live (TTL) per i dati della raccolta, che specifica per quanto tempo i dati devono essere conservati prima di essere cancellati automaticamente.

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

Imposta MMAP

Configura la proprietà di mappatura della memoria (MMAP) per l'insieme, che determina se i dati sono mappati in memoria per migliorare le prestazioni delle query. Per ulteriori informazioni, consultare Configurazione della mappatura della 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
    }
)

Abbandonare una raccolta

Se una raccolta non è più necessaria, è possibile 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": {}
# }