milvus-logo
LFAI
Home
  • Guide de l'utilisateur

Gérer les collections

Ce guide vous explique comment créer et gérer des collections à l'aide du SDK de votre choix.

Avant de commencer

Vue d'ensemble

Dans Milvus, vous stockez vos incorporations vectorielles dans des collections. Tous les encastrements vectoriels d'une collection partagent la même dimensionnalité et la même métrique de distance pour mesurer la similarité.

Les collections Milvus prennent en charge les champs dynamiques (c'est-à-dire les champs non prédéfinis dans le schéma) et l'incrémentation automatique des clés primaires.

Pour répondre à différentes préférences, Milvus propose deux méthodes de création d'une collection. L'une permet une configuration rapide, tandis que l'autre permet une personnalisation détaillée du schéma de la collection et des paramètres de l'index.

En outre, vous pouvez visualiser, charger, libérer et supprimer une collection si nécessaire.

Créer une collection

Vous pouvez créer une collection de l'une ou l'autre des manières suivantes :

  • Configuration rapide

    De cette manière, vous pouvez créer une collection en lui donnant simplement un nom et en spécifiant le nombre de dimensions des encastrements vectoriels à stocker dans cette collection. Pour plus de détails, voir Configuration rapide.

  • Configuration personnalisée

    Au lieu de laisser In Milvus décider de presque tout pour votre collection, vous pouvez déterminer vous-même les paramètres de schéma et d'index de la collection. Pour plus de détails, voir Configuration personnalisée.

Configuration rapide

Dans le contexte du grand bond en avant de l'industrie de l'IA, la plupart des développeurs ont simplement besoin d'une collection simple mais dynamique pour commencer. Milvus permet une configuration rapide d'une telle collection avec seulement trois arguments :

  • Nom de la collection à créer,

  • Dimension des encastrements vectoriels à insérer, et

  • Type de métrique utilisé pour mesurer les similarités entre les intégrations vectorielles.

Pour une configuration rapide, utilisez la méthode create_collection() de la classe MilvusClient pour créer une collection avec le nom et la dimension spécifiés.

Pour une configuration rapide, utilisez la méthode createCollection() de la classe MilvusClientV2 pour créer une collection avec le nom et la dimension spécifiés.

Pour une mise en place rapide, utilisez la méthode createCollection() de la classe MilvusClient pour créer une collection avec le nom et la dimension spécifiés.

Pour une configuration rapide, utilisez le point de terminaison POST /v2/vectordb/collections/create pour créer une collection avec le nom et la dimension spécifiés.

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 collection générée dans le code ci-dessus ne contient que deux champs : id (en tant que clé primaire) et vector (en tant que champ vectoriel), les paramètres auto_id et enable_dynamic_field étant activés par défaut.

  • auto_id

    L'activation de ce paramètre garantit que la clé primaire s'incrémente automatiquement. Il n'est pas nécessaire de fournir manuellement des clés primaires lors de l'insertion des données.

  • enable_dynamic_field

    Lorsque cette option est activée, tous les champs, à l'exception de id et vector dans les données à insérer, sont traités comme des champs dynamiques. Ces champs supplémentaires sont enregistrés sous forme de paires clé-valeur dans un champ spécial appelé $meta. Cette fonction permet d'inclure des champs supplémentaires lors de l'insertion des données.

La collection indexée et chargée automatiquement à partir du code fourni est prête pour l'insertion immédiate des données.

Configuration personnalisée

Au lieu de laisser Milvus décider de presque tout pour votre collection, vous pouvez déterminer vous-même le schéma et les paramètres d'indexation de la collection.

Étape 1 : configuration du schéma

Un schéma définit la structure d'une collection. Dans le schéma, vous avez la possibilité d'activer ou de désactiver enable_dynamic_field, d'ajouter des champs prédéfinis et de définir des attributs pour chaque champ. Pour une explication détaillée du concept et des types de données disponibles, reportez-vous à Schema Explained.

Pour configurer un schéma, utilisez create_schema() pour créer un objet schéma et add_field() pour ajouter des champs au schéma.

Pour configurer un schéma, utilisez createSchema() pour créer un objet schéma et addField() pour ajouter des champs au schéma.

Pour configurer un schéma, utilisez createCollection().

Pour configurer un schéma, vous devez définir un objet JSON qui respecte le format du schéma tel qu'il est affiché sur la page de référence du point de terminaison de l'API. POST /v2/vectordb/collections/create page de référence du point de terminaison de l'API.

# 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 \
    } \
}]'
Paramètres Description
auto_id Détermine si le champ primaire s'incrémente automatiquement.
La valeur True permet d'incrémenter automatiquement le champ primaire. Dans ce cas, le champ primaire ne doit pas être inclus dans les données à insérer pour éviter les erreurs. Les ID générés automatiquement ont une longueur fixe et ne peuvent pas être modifiés.
enable_dynamic_field Détermine si Milvus enregistre les valeurs des champs non définis dans un champ dynamique si les données insérées dans la collection cible comprennent des champs qui ne sont pas définis dans le schéma de la collection.
Si ce paramètre a la valeur True, Milvus crée un champ appelé $meta pour stocker tous les champs non définis et leurs valeurs à partir des données insérées.
field_name Le nom du champ.
datatype Le type de données du champ. Pour obtenir la liste des types de données disponibles, reportez-vous à la section Type de données.
is_primary Si le champ actuel est le champ primaire d'une collection.
Chaque collection n'a qu'un seul champ primaire. Un champ primaire doit être de type DataType.INT64 ou DataType.VARCHAR.
dim Dimension de l'intégration vectorielle.
Cette information est obligatoire pour les champs de type DataType.FLOAT_VECTOR, DataType.BINARY_VECTOR, DataType.FLOAT16_VECTOR ou DataType.BFLOAT16_VECTOR. Si vous utilisez le type DataType.SPARSE_FLOAT_VECTOR, omettez ce paramètre.
Paramètre Description du champ
fieldName Le nom du champ.
dataType Le type de données du champ. Pour obtenir la liste des types de données disponibles, reportez-vous à la rubrique DataType.
isPrimaryKey Indique si le champ actuel est le champ primaire d'une collection.
Chaque collection n'a qu'un seul champ primaire. Un champ primaire doit être de type DataType.Int64 ou DataType.VarChar.
autoID Permet au champ primaire de s'incrémenter automatiquement.
La valeur true permet au champ primaire de s'incrémenter automatiquement. Dans ce cas, le champ primaire ne doit pas être inclus dans les données à insérer pour éviter les erreurs.
dimension La dimension des encastrements vectoriels.
Ce paramètre est obligatoire pour un champ de type DataType.FloatVector, DataType.BinaryVector, DataType.Float16Vector ou DataType.BFloat16Vector.
Paramètre Description du champ
name Le nom du champ.
data_type Le type de données du champ. Pour une énumération de tous les types de données disponibles, voir DataType.
is_primary_key Indique si le champ actuel est le champ primaire d'une collection.
Chaque collection ne possède qu'un seul champ primaire. Un champ primaire doit être de type DataType.INT64 ou DataType.VARCHAR.
auto_id Indique si le champ primaire s'incrémente automatiquement lors de l'insertion de données dans cette collection.
La valeur par défaut est False. La valeur True permet d'incrémenter automatiquement le champ primaire. Ne tenez pas compte de ce paramètre si vous devez configurer une collection avec un schéma personnalisé.
dim La dimensionnalité du champ de la collection qui contient les intégrations vectorielles.
La valeur doit être un entier supérieur à 1 et est généralement déterminée par le modèle que vous utilisez pour générer les intégrations vectorielles.
Paramètre Description
fieldName Le nom du champ à créer dans la collection cible.
dataType Le type de données des valeurs du champ.
isPrimary Indique si le champ actuel est le champ primaire. La valeur True fait du champ actuel le champ primaire.
elementTypeParams Paramètres de champ supplémentaires.
dim Un paramètre facultatif pour les champs FloatVector ou BinaryVector qui détermine la dimension du vecteur.

Etape 2 : Définition des paramètres d'index

Les paramètres d'indexation déterminent la manière dont Milvus organise vos données au sein d'une collection. Vous pouvez personnaliser le processus d'indexation pour des champs spécifiques en ajustant leurs metric_type et index_type. Pour le champ vectoriel, vous pouvez sélectionner COSINE, L2, IP, HAMMING, ou JACCARD comme metric_type, en fonction du type de vecteurs avec lequel vous travaillez. Pour plus d'informations, reportez-vous à la section Métriques de similarité.

Pour définir les paramètres de l'index, utilisez prepare_index_params() pour préparer les paramètres de l'index et add_index() pour ajouter l'index.

Pour définir les paramètres d'index, utilisez IndexParam.

Pour définir les paramètres de l'index, utilisez createIndex().

Pour configurer les paramètres d'index, vous devez définir un objet JSON qui respecte le format des paramètres d'index tel qu'il est indiqué sur la page de référence du point de terminaison de l'API POST /v2/vectordb/collections/create page de référence du point de terminaison de l'API.

# 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 \
  } \
}]'
Paramètres Description de l'objet
field_name Le nom du fichier cible auquel cet objet s'applique.
index_type Le nom de l'algorithme utilisé pour organiser les données dans le champ spécifique. Pour les algorithmes applicables, voir Index en mémoire et Index sur disque.
metric_type L'algorithme utilisé pour mesurer la similarité entre les vecteurs. Les valeurs possibles sont IP, L2, COSINE, JACCARD, HAMMING. Cette option n'est disponible que si le champ spécifié est un champ vectoriel. Pour plus d'informations, voir Index pris en charge dans Milvus.
params Les paramètres de réglage fin pour le type d'index spécifié. Pour plus de détails sur les clés et les plages de valeurs possibles, voir Index en mémoire.
Paramètre Description
fieldName Le nom du champ cible auquel s'applique cet objet IndexParam.
indexType Le nom de l'algorithme utilisé pour organiser les données dans le champ spécifique. Pour les algorithmes applicables, voir Index en mémoire et Index sur disque.
metricType La métrique de distance à utiliser pour l'index. Les valeurs possibles sont IP, L2, COSINE, JACCARD, HAMMING.
extraParams Paramètres d'index supplémentaires. Pour plus de détails, voir Index en mémoire et Index sur disque.
Paramètre Description de l'index
field_name Nom du champ cible sur lequel un index doit être créé.
index_type Nom de l'algorithme utilisé pour organiser les données dans le champ spécifique. Pour les algorithmes applicables, voir Index en mémoire et Index sur disque.
metric_type L'algorithme utilisé pour mesurer la similarité entre les vecteurs. Les valeurs possibles sont IP, L2, COSINE, JACCARD, HAMMING. Cette option n'est disponible que si le champ spécifié est un champ vectoriel. Pour plus d'informations, voir Index pris en charge dans Milvus.
params Les paramètres de réglage fin pour le type d'index spécifié. Pour plus de détails sur les clés et les plages de valeurs possibles, voir Index en mémoire.
Paramètre Description de l'index
fieldName Le nom du champ cible sur lequel un index doit être créé.
indexName Le nom de l'index à créer. La valeur par défaut est le nom du champ cible.
metricType L'algorithme utilisé pour mesurer la similarité entre les vecteurs. Les valeurs possibles sont IP, L2, COSINE, JACCARD, HAMMING. Cette option n'est disponible que si le champ spécifié est un champ vectoriel. Pour plus d'informations, voir Index pris en charge dans Milvus.
params Le type d'index et les paramètres associés. Pour plus de détails, voir Index en mémoire.
params.index_type Le type d'index à créer.
params.nlist Le nombre d'unités de cluster. Ceci s'applique aux types d'index liés à l'IVF.

L'extrait de code ci-dessus montre comment configurer les paramètres d'index pour un champ vectoriel et un champ scalaire, respectivement. Pour le champ vectoriel, définissez à la fois le type métrique et le type d'index. Pour un champ scalaire, définissez uniquement le type d'index. Il est recommandé de créer un index pour le champ vectoriel et tout champ scalaire fréquemment utilisé pour le filtrage.

Étape 3 : Créer la collection

Vous avez la possibilité de créer une collection et un fichier d'index séparément ou de créer une collection avec l'index chargé simultanément lors de la création.

Utilisez create_collection() pour créer une collection avec les paramètres de schéma et d'index spécifiés et get_load_state() pour vérifier l'état de chargement de la collection.

Utilisez createCollection() pour créer une collection avec les paramètres de schéma et d'index spécifiés et getLoadState() pour vérifier l'état de chargement de la collection.

Utilisez createCollection() pour créer une collection avec les paramètres de schéma et d'index spécifiés et getLoadState() pour vérifier l'état de chargement de la collection.

  • Créer une collection dont l'index est chargé simultanément à la création.

    # 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 collection créée ci-dessus est chargée automatiquement. Pour en savoir plus sur le chargement et la libération d'une collection, voir Charger et libérer une collection.

  • Créer une collection et un fichier d'index séparément.

    # 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 collection créée ci-dessus n'est pas chargée automatiquement. Vous pouvez créer un index pour la collection comme suit. La création d'un index pour la collection de manière séparée ne charge pas automatiquement la collection. Pour plus d'informations, reportez-vous à la section Charger et libérer une collection.

    Paramètre Description de la collection
    collection_name Le nom de la collection.
    schema Le schéma de cette collection.
    La valeur None indique que la collection sera créée avec les paramètres par défaut.
    Pour configurer une collection avec un schéma personnalisé, vous devez créer un objet CollectionSchema et le référencer ici. Dans ce cas, Milvus ignore tous les autres paramètres relatifs au schéma figurant dans la demande.
    index_params Les paramètres de construction de l'index sur le champ de vecteurs dans cette collection. Pour configurer une collection avec un schéma personnalisé et charger automatiquement la collection en mémoire, vous devez créer un objet IndexParams et y faire référence ici.
    Vous devez au moins ajouter un index pour le champ vectoriel dans cette collection. Vous pouvez également ignorer ce paramètre si vous préférez configurer les paramètres d'index ultérieurement.

    Paramètre Description
    collectionName Le nom de la collection.
    collectionSchema Le schéma de cette collection.
    Le fait de laisser ce paramètre vide indique que cette collection sera créée avec les paramètres par défaut. Pour configurer une collection avec un schéma personnalisé, vous devez créer un objet CollectionSchema et le référencer ici.
    indexParams Les paramètres de construction de l'index sur le champ de vecteurs dans cette collection. Pour configurer une collection avec un schéma personnalisé et charger automatiquement la collection en mémoire, créez un objet IndexParams avec une liste d'objets IndexParam et faites-y référence ici.

    Paramètre Description de la collection
    collection_name Le nom de la collection.
    fields Les champs de la collection.
    index_params Les paramètres d'index pour la collection à créer.

    Paramètre Description
    collectionName Le nom de la collection.
    schema Le schéma est responsable de l'organisation des données dans la collection cible. Un schéma valide doit comporter plusieurs champs, dont une clé primaire, un champ vectoriel et plusieurs champs scalaires.
    schema.autoID Cette option permet d'incrémenter automatiquement le champ primaire. La valeur True permet au champ primaire de s'incrémenter automatiquement. Dans ce cas, le champ primaire ne doit pas être inclus dans les données à insérer pour éviter les erreurs. Ce paramètre doit être défini dans le champ dont la valeur de is_primary est True.
    schema.enableDynamicField Permet ou non d'utiliser le champ réservé $meta pour contenir des champs non définis par le schéma dans des paires clé-valeur.
    fields Une liste d'objets de champ.
    fields.fieldName Le nom du champ à créer dans la collection cible.
    fields.dataType Le type de données des valeurs du champ.
    fields.isPrimary Si le champ actuel est le champ primaire. Si cette valeur est True, le champ actuel devient le champ primaire.
    fields.elementTypeParams Paramètres de champ supplémentaires.
    fields.elementTypeParams.dim Un paramètre facultatif pour les champs FloatVector ou BinaryVector qui détermine la dimension du vecteur.

    La collection créée ci-dessus n'est pas chargée automatiquement. Vous pouvez créer un index pour la collection comme suit. La création d'un index pour la collection de manière distincte n'entraîne pas le chargement automatique de la collection. Pour plus d'informations, reportez-vous à la section Charger et libérer une collection.

    # 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"
    #     }
    # }
    
    Paramètres Description de la collection
    collection_name Le nom de la collection.
    index_params Un objet IndexParams contenant une liste d'objets IndexParam.
Paramètre Description de l'objet
collectionName Le nom de la collection.
indexParams Une liste d'objets IndexParam.
Paramètre Description
collection_name Le nom de la collection.
field_name Le nom du champ dans lequel créer un index.
index_type Le nom de l'algorithme utilisé pour organiser les données dans le champ spécifique. Pour les algorithmes applicables, voir Index en mémoire et Index sur disque.
metric_type L'algorithme utilisé pour mesurer la similarité entre les vecteurs. Les valeurs possibles sont IP, L2, COSINE, JACCARD, HAMMING. Cette option n'est disponible que si le champ spécifié est un champ vectoriel. Pour plus d'informations, voir Index pris en charge dans Milvus.
params Les paramètres de réglage fin pour le type d'index spécifié. Pour plus de détails sur les clés et les plages de valeurs possibles, voir Index en mémoire.
Paramètre Description
collectionName Le nom de la collection.
indexParams Les paramètres d'index pour la collection à créer.
indexParams.metricType Le type de métrique de similarité utilisé pour construire l'index. La valeur par défaut est COSINE.
indexParams.fieldName Le nom du champ cible sur lequel un index doit être créé.
indexParams.indexName Le nom de l'index à créer, la valeur par défaut étant le nom du champ cible.
indexParams.indexConfig.index_type Le type de l'index à créer.
indexParams.indexConfig.nlist Le nombre d'unités de cluster. Ceci s'applique aux types d'index liés à la FIV.

Visualiser les collections

Pour vérifier les détails d'une collection existante, utilisez la fonction describe_collection().

Pour vérifier les détails d'une collection existante, utilisez la fonction describeCollection().

Pour vérifier les détails d'une collection existante, utilisez la fonction describeCollection().

Pour afficher la définition d'une collection, vous pouvez utiliser les boutons POST /v2/vectordb/collections/describe et l'API POST /v2/vectordb/collections/list pour afficher la définition d'une collection.

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

Pour lister toutes les collections existantes, vous pouvez procéder comme suit :

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

Charger et libérer une collection

Au cours du processus de chargement d'une collection, Milvus charge le fichier d'index de la collection dans la mémoire. Inversement, lors de la libération d'une collection, Milvus décharge le fichier d'index de la mémoire. Avant d'effectuer des recherches dans une collection, il faut s'assurer que la collection est chargée.

Chargement d'une collection

Pour charger une collection, utilisez la méthode load_collection() en spécifiant le nom de la collection. Vous pouvez également définir replica_number pour déterminer le nombre de répliques en mémoire des segments de données à créer sur les nœuds de requête lorsque la collection est chargée.

  • Milvus Standalone : La valeur maximale autorisée pour replica_number est 1.
  • Milvus Cluster : La valeur maximale ne doit pas dépasser la valeur queryNode.replicas définie dans vos configurations Milvus. Pour plus de détails, voir Configurations relatives aux nœuds de requête.

Pour charger une collection, utilisez la méthode loadCollection() en spécifiant le nom de la collection.

Pour charger une collection, utilisez la méthode loadCollection() en spécifiant le nom de la collection.

Pour charger une collection, vous pouvez utiliser les méthodes POST /v2/vectordb/collections/load et l'API POST /v2/vectordb/collections/get_load_state pour charger une collection.

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

Charger partiellement une collection (aperçu public)

Cette fonctionnalité est actuellement en avant-première publique. L'API et la fonctionnalité peuvent changer à l'avenir.

Lors de la réception de votre demande de chargement, Milvus charge tous les index des champs vectoriels et toutes les données des champs scalaires en mémoire. Si certains champs ne doivent pas être impliqués dans les recherches et les requêtes, vous pouvez les exclure du chargement pour réduire l'utilisation de la mémoire et améliorer les performances de recherche.

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

Notez que seuls les champs répertoriés sur load_fields peuvent être utilisés comme conditions de filtrage et champs de sortie dans les recherches et les requêtes. Vous devez toujours inclure la clé primaire dans la liste. Les noms de champs exclus du chargement ne seront pas disponibles pour le filtrage ou la sortie.

Vous pouvez utiliser skip_load_dynamic_field=True pour ne pas charger le champ dynamique. Milvus traite le champ dynamique comme un champ unique, de sorte que toutes les clés du champ dynamique seront incluses ou exclues ensemble.

Libération d'une collection

Pour libérer une collection, utilisez la méthode release_collection() en spécifiant le nom de la collection.

Pour libérer une collection, utilisez la méthode releaseCollection() en spécifiant le nom de la collection.

Pour libérer une collection, utilisez la méthode releaseCollection() en spécifiant le nom de la collection.

Pour libérer une collection, vous pouvez utiliser les méthodes POST /v2/vectordb/collections/release et l'API POST /v2/vectordb/collections/get_load_state de l'API.

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

Définir des alias

Vous pouvez attribuer des alias aux collections afin de les rendre plus significatives dans un contexte spécifique. Vous pouvez attribuer plusieurs alias à une collection, mais plusieurs collections ne peuvent pas partager un alias.

Créer des alias

Pour créer des alias, utilisez la méthode create_alias() en spécifiant le nom de la collection et l'alias.

Pour créer des alias, utilisez la méthode createAlias() en spécifiant le nom de la collection et l'alias.

Pour créer des alias, utilisez la méthode createAlias() en spécifiant le nom de la collection et l'alias.

Pour créer des alias pour une collection, vous pouvez utiliser le point de terminaison de l'API POST /v2/vectordb/aliases/create pour créer des alias pour une collection.

# 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": {}
# }
Paramètres Description de l'alias
collection_name Le nom de la collection pour laquelle un alias doit être créé.
alias L'alias de la collection. Avant cette opération, assurez-vous que l'alias n'existe pas déjà. Si c'est le cas, des exceptions se produiront.
Paramètre Description de l'alias
collectionName Le nom de la collection pour laquelle un alias doit être créé.
alias L'alias de la collection. Avant cette opération, assurez-vous que l'alias n'existe pas déjà. Si c'est le cas, des exceptions se produiront.
Paramètre Description de l'alias
collection_name Le nom de la collection pour laquelle un alias doit être créé.
alias L'alias de la collection. Avant cette opération, assurez-vous que l'alias n'existe pas déjà. Si c'est le cas, des exceptions se produiront.
Paramètre Description de l'alias
collectionName Le nom de la collection pour laquelle un alias doit être créé.
aliasName L'alias de la collection. Avant cette opération, assurez-vous que l'alias n'existe pas déjà. Si c'est le cas, des exceptions se produiront.

Lister les alias

Pour dresser la liste des alias, utilisez la méthode list_aliases() en spécifiant le nom de la collection.

Pour dresser la liste des alias, utilisez la méthode listAliases() en spécifiant le nom de la collection.

Pour dresser la liste des alias, utilisez la méthode listAliases() en spécifiant le nom de la collection.

Pour répertorier les alias d'une collection, vous pouvez utiliser le point de terminaison de l'API POST /v2/vectordb/aliases/list point de terminaison de l'API.

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

Décrire les alias

Pour décrire les alias, utilisez la méthode describe_alias() en spécifiant l'alias.

Pour décrire les alias, utilisez la méthode describeAlias() en spécifiant l'alias.

Pour décrire les alias, utilisez la méthode describeAlias() en spécifiant l'alias.

Pour décrire les alias d'une collection, vous pouvez utiliser le point de terminaison de l'API POST /v2/vectordb/aliases/describe point de terminaison de l'API.

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

Réaffectation des alias

Pour réaffecter des alias à d'autres collections, utilisez la méthode alter_alias() en spécifiant le nom de la collection et l'alias.

Pour réaffecter des alias à d'autres collections, utilisez la méthode alterAlias() en spécifiant le nom de la collection et l'alias.

Pour réaffecter des alias à d'autres collections, utilisez la méthode alterAlias() en spécifiant le nom de la collection et l'alias.

Pour réaffecter des alias à d'autres collections, vous pouvez utiliser le point de terminaison de l'API POST /v2/vectordb/aliases/alter pour réaffecter des alias à d'autres collections, vous pouvez utiliser le point de terminaison de l'API.

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

Supprimer des alias

Pour supprimer des alias, utilisez la méthode drop_alias() en spécifiant l'alias.

Pour supprimer des alias, utilisez la méthode dropAlias() en spécifiant l'alias.

Pour supprimer des alias, utilisez la méthode dropAlias() en spécifiant l'alias.

Pour supprimer les alias d'une collection, vous pouvez utiliser le point de terminaison de l'API POST /v2/vectordb/aliases/drop de l'API.

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

Définir des propriétés

Vous pouvez définir les propriétés d'une collection, telles que ttl.seconds et mmap.enabled. Pour plus d'informations, reportez-vous à set_properties().

Les extraits de code de cette section utilisent le module ORM PyMilvus pour interagir avec Milvus. Des extraits de code avec le nouveau SDK MilvusClient seront bientôt disponibles.

Définir le TTL

Définit le délai de conservation (TTL) des données de la collection, qui spécifie la durée pendant laquelle les données doivent être conservées avant d'être automatiquement supprimées.

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

Définir MMAP

Configurer la propriété de mappage de la mémoire (MMAP) pour la collection, qui détermine si les données sont mappées en mémoire pour améliorer les performances des requêtes. Pour plus d'informations, reportez-vous à la section Configurer le mappage de la mémoire.

Avant de définir la propriété MMAP, libérez d'abord la collection. Sinon, une erreur se produira.

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

Abandonner une collecte

Si une collection n'est plus nécessaire, vous pouvez l'abandonner.

Pour supprimer une collection, utilisez la méthode drop_collection() en spécifiant le nom de la collection.

Pour supprimer une collection, utilisez la méthode dropCollection() en spécifiant le nom de la collection.

Pour supprimer une collection, utilisez la méthode dropCollection() en spécifiant le nom de la collection.

Pour déposer une collection, vous pouvez utiliser le point de terminaison POST /v2/vectordb/collections/drop pour déposer une collection.

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

Traduit parDeepLogo

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
Feedback

Cette page a-t - elle été utile ?