Google Gemini

Utilisez un modèle d'intégration Google Gemini avec Milvus en choisissant un modèle et en configurant Milvus avec votre clé API Gemini.

Choisir un modèle d'intégration

Milvus prend en charge les modèles d'intégration fournis par Google Gemini. Vous trouverez ci-dessous les modèles d'intégration Gemini actuellement disponibles, à titre de référence rapide :

Nom du modèle	Dimensions	Nombre maximal de jetons	Description
gemini-embedding-001	Valeur par défaut : 3 072 (recommandé : 768, 1 536 ou 3 072)	8,192	Modèle d'intégration de texte à dimensions flexibles, entraîné à l'aide de l'apprentissage par représentation de Matryoshka (MRL).
gemini-embedding-2	Valeur par défaut : 3 072 (recommandée : 768, 1 536 ou 3 072)	8,192	Premier modèle d'intégration multimodale de Google, prenant en charge le texte, les images, la vidéo, l'audio et les documents dans un espace d'intégration unifié.

Les deux modèles sont formés à l'aide de la technique Matryoshka Representation Learning (MRL), qui permet des dimensions de sortie flexibles via le paramètre dim. Il est recommandé de commencer avec 768 dimensions et de passer à 1 536 ou 3 072 si nécessaire. Pour plus de détails, voir les modèles d'intégration Gemini.

Les modèles d'intégration Gemini prennent également en charge un paramètre de type de tâche qui optimise les intégrations pour des cas d'utilisation spécifiques. Milvus définit automatiquement le type de tâche en fonction de l'opération :

• Insert / Upsert: RETRIEVAL_DOCUMENT

• Recherche: RETRIEVAL_QUERY

Vous pouvez remplacer ce paramètre en spécifiant explicitement un paramètre task (par exemple, SEMANTIC_SIMILARITY, CLASSIFICATION, CLUSTERING).

Configurer les informations d'identification

Milvus doit connaître votre clé API Gemini avant de pouvoir demander des incorporations. Milvus propose deux méthodes pour configurer les informations d'identification :

• Fichier de configuration (recommandé) : Stockez la clé API à l'adresse milvus.yaml pour que chaque redémarrage et chaque nœud la récupère automatiquement.

• Variables d'environnement : Injecter la clé au moment du déploiement - idéal pour Docker Compose.

Choisissez l'une des deux méthodes ci-dessous : le fichier de configuration est plus facile à maintenir sur les machines nues et les machines virtuelles, tandis que la méthode des variables d'environnement convient aux flux de travail des conteneurs.

Si une clé API pour le même fournisseur est présente à la fois dans le fichier de configuration et dans une variable d'environnement, Milvus utilise toujours la valeur dans milvus.yaml et ignore la variable d'environnement.

Option 1 : Fichier de configuration (recommandé et plus prioritaire)

Conservez vos clés API dans milvus.yaml; Milvus les lit au démarrage et remplace toute variable d'environnement pour le même fournisseur.

1. Déclarez vos clés sous credential :

   Vous pouvez lister une ou plusieurs clés API - donnez à chacune une étiquette que vous inventez et à laquelle vous ferez référence plus tard.

   # milvus.yaml
   credential:
     apikey_dev:            # dev environment
       apikey: <YOUR_DEV_KEY>
     apikey_prod:           # production environment
       apikey: <YOUR_PROD_KEY>    
   

   Le fait de placer les clés d'API ici les rend persistantes lors des redémarrages et vous permet de changer de clé en changeant simplement d'étiquette.

2. Indiquer à Milvus la clé à utiliser pour les appels Gemini

   Dans le même fichier, indiquez au fournisseur Gemini l'étiquette que vous voulez qu'il utilise.

   function:
     textEmbedding:
       providers:
         gemini:
           credential: apikey_dev      # ← choose any label you defined above
   

   Cela permet de lier une clé spécifique à chaque demande que Milvus envoie au point de terminaison Gemini embeddings.

Option 2 : Variable d'environnement

Utilisez cette méthode lorsque vous exécutez Milvus avec Docker Compose et que vous préférez garder les secrets hors des fichiers et des images.

Milvus se rabat sur la variable d'environnement uniquement si aucune clé pour le fournisseur n'est trouvée dans milvus.yaml.

Variable	Obligatoire	Description de la variable
MILVUS_GEMINI_API_KEY	Oui	Rend la clé Gemini disponible dans chaque conteneur Milvus (ignorée lorsqu'une clé pour Gemini existe dans milvus.yaml).

Dans votre fichier docker-compose.yaml, définissez la variable d'environnement MILVUS_GEMINI_API_KEY.

# docker-compose.yaml (standalone service section)
standalone:
  # ... other configurations ...
  environment:
    # ... other environment variables ...
    # Set the environment variable pointing to the Gemini API key inside the container
    MILVUS_GEMINI_API_KEY: <YOUR_GEMINI_API_KEY>

Le bloc environment: injecte la clé uniquement dans le conteneur Milvus, laissant votre système d'exploitation hôte intact. Pour plus de détails, voir Configurer Milvus avec Docker Compose.

Étape 1 : Créer une collection avec une fonction d'incorporation de texte

Définir les champs du schéma

Pour utiliser une fonction d'incorporation, créez une collection avec un schéma spécifique. Ce schéma doit comprendre au moins trois champs nécessaires :

• Le champ primaire qui identifie de manière unique chaque entité d'une collection.

• Un champ VARCHAR qui stocke les données brutes à intégrer.

• Un champ vectoriel réservé au stockage des incorporations vectorielles denses que la fonction d'incorporation de texte générera pour le champ VARCHAR.

L'exemple suivant définit un schéma avec un champ scalaire "document" pour stocker les données textuelles et un champ vectoriel "dense" pour stocker les enchâssements qui seront générés par le module Function. N'oubliez pas de définir la dimension du vecteur (dim) pour qu'elle corresponde à la sortie du modèle d'intégration que vous avez choisi.

from pymilvus import MilvusClient, DataType, Function, FunctionType

# Initialize Milvus client
client = MilvusClient(
    uri="http://localhost:19530",
)

# Create a new schema for the collection
schema = client.create_schema()

# Add primary field "id"
schema.add_field("id", DataType.INT64, is_primary=True, auto_id=False)

# Add scalar field "document" for storing textual data
schema.add_field("document", DataType.VARCHAR, max_length=9000)

# Add vector field "dense" for storing embeddings.
# IMPORTANT: Set dim to match the exact output dimension of the embedding model.
# For instance, Gemini's gemini-embedding-001 model outputs 3072-dimensional vectors by default,
# but can be shortened to 768 or 1536 dimensions.
schema.add_field("dense", DataType.FLOAT_VECTOR, dim=768)

Définir la fonction d'intégration de texte

La fonction d'incorporation de texte convertit automatiquement les données brutes stockées dans un champ VARCHAR en embeddings et les stocke dans le champ vectoriel explicitement défini.

L'exemple ci-dessous ajoute un module Function (gemini_embedding) qui convertit le champ scalaire "document" en embeddings, en stockant les vecteurs résultants dans le champ vectoriel "dense" défini précédemment.

# Define embedding function (example: Gemini provider)
text_embedding_function = Function(
    name="gemini_embedding",                        # Unique identifier for this embedding function
    function_type=FunctionType.TEXTEMBEDDING,       # Type of embedding function
    input_field_names=["document"],                 # Scalar field to embed
    output_field_names=["dense"],                   # Vector field to store embeddings
    params={                                        # Provider-specific configuration (highest priority)
        "provider": "gemini",                       # Embedding model provider
        "model_name": "gemini-embedding-001",       # Embedding model
        # Optional parameters:
        # "credential": "apikey_dev",               # Optional: Credential label specified in milvus.yaml
        # "dim": "768",                             # Optional: Output vector dimension (default 3072)
        # "task": "RETRIEVAL_DOCUMENT",             # Optional: Task type for embedding optimization
    }
)

# Add the embedding function to your schema
schema.add_function(text_embedding_function)

Types de tâches pris en charge pour le paramètre task :

• RETRIEVAL_DOCUMENT - Optimise les embeddings pour l'indexation de documents (par défaut pour insert/upsert).

• RETRIEVAL_QUERY - Optimise les enchâssements pour la recherche de requêtes (par défaut pour la recherche).

• SEMANTIC_SIMILARITY - Optimise les embeddings pour la mesure de la similarité des textes.

• CLASSIFICATION - Optimise les enchâssements pour la classification des textes.

• CLUSTERING - Optimise les incorporations pour le regroupement (clustering).

S'il n'est pas explicitement défini, Milvus utilise automatiquement RETRIEVAL_DOCUMENT lors de l'insertion et de la mise à jour et RETRIEVAL_QUERY lors de la recherche.

Configurer l'index

Après avoir défini le schéma avec les champs nécessaires et la fonction intégrée, configurez l'index pour votre collection. Pour simplifier ce processus, utilisez AUTOINDEX comme index_type, une option qui permet à Milvus de choisir et de configurer le type d'index le plus approprié en fonction de la structure de vos données.

# Prepare index parameters
index_params = client.prepare_index_params()

# Add AUTOINDEX to automatically select optimal indexing method
index_params.add_index(
    field_name="dense",
    index_type="AUTOINDEX",
    metric_type="COSINE" 
)

Création de la collection

Créez maintenant la collection à l'aide du schéma et des paramètres d'index définis.

# Create collection named "demo"
client.create_collection(
    collection_name='demo', 
    schema=schema, 
    index_params=index_params
)

Etape 2 : Insérer des données

Après avoir configuré votre collection et votre index, vous êtes prêt à insérer vos données brutes. Dans ce processus, il vous suffit de fournir le texte brut. Le module Function que nous avons défini précédemment génère automatiquement le vecteur sparse correspondant pour chaque entrée de texte.

# Insert sample documents
client.insert('demo', [
    {'id': 1, 'document': 'Milvus simplifies semantic search through embeddings.'},
    {'id': 2, 'document': 'Vector embeddings convert text into searchable numeric data.'},
    {'id': 3, 'document': 'Semantic search helps users find relevant information quickly.'},
])

Étape 3 : Recherche dans le texte

Après l'insertion des données, effectuez une recherche sémantique à l'aide du texte brut de la requête. Milvus convertit automatiquement votre requête en un vecteur d'intégration, récupère les documents pertinents en fonction de leur similarité et renvoie les meilleurs résultats.

# Perform semantic search
results = client.search(
    collection_name='demo', 
    data=['How does Milvus handle semantic search?'], # Use text query rather than query vector
    anns_field='dense',   # Use the vector field that stores embeddings
    limit=1,
    output_fields=['document'],
)

print(results)

Pour plus d'informations sur les opérations de recherche et d'interrogation, reportez-vous à la section Recherche et interrogation vectorielles de base.