Introduction de la fonction d'intégration : Comment Milvus 2.6 rationalise la vectorisation et la recherche sémantique

Si vous avez déjà construit une application de recherche vectorielle, vous connaissez déjà un peu trop bien le flux de travail. Avant de pouvoir être stockées, les données doivent d'abord être transformées en vecteurs à l'aide d'un modèle d'incorporation, puis nettoyées et formatées, avant d'être finalement intégrées dans votre base de données vectorielles. Chaque requête suit le même processus : incorporation de l'entrée, recherche de similarité, puis mise en correspondance des identifiants résultants avec les documents ou enregistrements d'origine. Cela fonctionne, mais crée un enchevêtrement distribué de scripts de prétraitement, de pipelines d'intégration et de code de collage dont vous devez assurer la maintenance.

Milvus, une base de données vectorielles open-source haute performance, fait désormais un grand pas en avant pour simplifier tout cela. Milvus 2.6 introduit la fonction Data-in, Data-out (également connue sous le nom de fonction d'intégration), une capacité d'intégration intégrée qui se connecte directement aux principaux fournisseurs de modèles tels que OpenAI, AWS Bedrock, Google Vertex AI et Hugging Face. Au lieu de gérer votre propre infrastructure d'intégration, Milvus peut désormais appeler ces modèles pour vous. Vous pouvez également insérer et interroger à l'aide de texte brut - et bientôt d'autres types de données - tandis que Milvus gère automatiquement la vectorisation au moment de l'écriture et de l'interrogation.

Dans la suite de ce billet, nous examinerons de plus près le fonctionnement de Data-in, Data-out, comment configurer les fournisseurs et les fonctions d'intégration, et comment vous pouvez l'utiliser pour rationaliser vos flux de recherche vectorielle de bout en bout.

Qu'est-ce que Data-in, Data-out ?

Data-in, Data-out dans Milvus 2.6 est construit sur le nouveau module Function - un cadre qui permet à Milvus de gérer la transformation des données et la génération d'intégration en interne, sans services de prétraitement externes. (Avec ce module, Milvus peut prendre des données d'entrée brutes, appeler directement un fournisseur d'intégration et écrire automatiquement les vecteurs résultants dans votre collection.

À un niveau élevé, le module Function transforme la génération d'intégration en une capacité de base de données native. Au lieu d'exécuter des pipelines d'intégration distincts, des travailleurs en arrière-plan ou des services de reranker, Milvus envoie désormais des demandes à votre fournisseur configuré, récupère les intégrations et les stocke avec vos données, le tout dans le chemin d'ingestion. Cela supprime la charge opérationnelle liée à la gestion de votre propre infrastructure d'intégration.

Data-in, Data-out apporte trois améliorations majeures au flux de travail Milvus :

• Insérer directement des données brutes - Vous pouvez désormais insérer du texte, des images ou d'autres types de données non traités directement dans Milvus. Il n'est pas nécessaire de les convertir en vecteurs au préalable.

• Configurer une fonction d'incorporation - Une fois que vous avez configuré un modèle d'incorporation dans Milvus, celui-ci gère automatiquement l'ensemble du processus d'incorporation. Milvus s'intègre de manière transparente à une série de fournisseurs de modèles, notamment OpenAI, AWS Bedrock, Google Vertex AI, Cohere et Hugging Face.

• Requête avec des entrées brutes - Vous pouvez désormais effectuer une recherche sémantique à l'aide de texte brut ou d'autres requêtes basées sur le contenu. Milvus utilise le même modèle configuré pour générer des enchâssements à la volée, effectuer une recherche de similarité et renvoyer des résultats pertinents.

En bref, Milvus incorpore désormais automatiquement vos données - et les réorganise éventuellement. La vectorisation devient une fonction intégrée de la base de données, ce qui élimine le besoin de services d'intégration externes ou de logique de prétraitement personnalisée.

Fonctionnement de Data-in, Data-out

Le diagramme ci-dessous illustre le fonctionnement de Data-in, Data-out dans Milvus.

Le flux de travail Data-in, Data-out peut être décomposé en six étapes principales :

1. Données d'entrée - L'utilisateur insère des données brutes - telles que du texte, des images ou d'autres types de contenu - directement dans Milvus sans effectuer de prétraitement externe.

2. Générer des embeddings - Le module Function invoque automatiquement le modèle d'embedding configuré via son API tierce, convertissant l'entrée brute en embeddings vectoriels en temps réel.

3. Stockage des embeddings - Milvus écrit les embeddings générés dans le champ vectoriel désigné dans votre collection, où ils deviennent disponibles pour les opérations de recherche de similarité.

4. Soumettre une requête - L'utilisateur émet une requête en texte brut ou basée sur le contenu à Milvus, comme pour l'étape de saisie.

5. Recherche sémantique - Milvus incorpore la requête à l'aide du même modèle configuré, exécute une recherche de similarité sur les vecteurs stockés et détermine les correspondances sémantiques les plus proches.

6. Renvoi des résultats - Milvus renvoie les k résultats les plus similaires - mappés à leurs données d'origine - directement à l'application.

Comment configurer Data-in, Data-out

Conditions préalables

• Installez la dernière version de Milvus 2.6.

• Préparez votre clé API d'intégration à partir d'un fournisseur pris en charge (par exemple, OpenAI, AWS Bedrock ou Cohere). Dans cet exemple, nous utiliserons Cohere comme fournisseur d'intégration.

Modifier la configuration de milvus.yaml

Si vous exécutez Milvus avec Docker Compose, vous devrez modifier le fichier milvus.yaml pour activer le module Function. Vous pouvez vous référer à la documentation officielle pour obtenir des conseils : Configure Milvus with Docker Compose (Des instructions pour d'autres méthodes de déploiement peuvent également être trouvées ici).

Dans le fichier de configuration, localisez les sections credential et function.

Ensuite, mettez à jour les champs apikey1.apikey et providers.cohere.

...
credential:
  aksk1:
    access_key_id:  # Your access_key_id
    secret_access_key:  # Your secret_access_key
  apikey1:
    apikey: "***********************" # Edit this section
  gcp1:
    credential_json:  # base64 based gcp credential data
# Any configuration related to functions
function:
  textEmbedding:
    providers:
                        ...
      cohere: # Edit the section below
        credential:  apikey1 # The name in the crendential configuration item
        enable: true # Whether to enable cohere model service
        url:  "https://api.cohere.com/v2/embed" # Your cohere embedding url, Default is the official embedding url
      ...
...

Une fois ces modifications effectuées, redémarrez Milvus pour appliquer la configuration mise à jour.

Utilisation de la fonctionnalité Data-in, Data-out

1. Définir le schéma de la collection

Pour activer la fonctionnalité d'intégration, le schéma de votre collection doit comprendre au moins trois champs :

• Champ de clé primaire (id ) - Identifie de manière unique chaque entité de la collection.

• Champ scalaire (document ) - Stocke les données brutes originales.

• Champ vectoriel (dense ) - Stocke les intégrations vectorielles générées.

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, OpenAI's text-embedding-3-small model outputs 1536-dimensional vectors.
# For dense vector, data type can be FLOAT_VECTOR or INT8_VECTOR
schema.add_field("dense", DataType.FLOAT_VECTOR, dim=1536) # Set dim according to the embedding model you use.

2. Définir la fonction d'intégration

Définissez ensuite la fonction d'intégration dans le schéma.

• name - Un identifiant unique pour la fonction.

• function_type - Défini à FunctionType.TEXTEMBEDDING pour les incorporations de texte. Milvus prend également en charge d'autres types de fonction tels que FunctionType.BM25 et FunctionType.RERANK. Voir Recherche plein texte et Aperçu du classificateur de décroissance pour plus de détails.

• input_field_names - Définit le champ d'entrée pour les données brutes (document).

• output_field_names - Définit le champ de sortie où les encastrements vectoriels seront stockés (dense).

• params - Contient les paramètres de configuration de la fonction d'intégration. Les valeurs de provider et model_name doivent correspondre aux entrées correspondantes de votre fichier de configuration milvus.yaml.

Remarque : chaque fonction doit avoir un name et un output_field_names uniques afin de distinguer les différentes logiques de transformation et d'éviter les conflits.

# Define embedding function (example: OpenAI provider)
text_embedding_function = Function(
    name="cohere_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": "cohere",                 # Embedding model provider
        "model_name": "embed-v4.0",     # Embedding model
        # "credential": "apikey1",            # Optional: Credential label
        # Optional parameters:
        # "dim": "1536",       # Optionally shorten the vector dimension
        # "user": "user123"    # Optional: identifier for API tracking
    }
)
# Add the embedding function to your schema
schema.add_function(text_embedding_function)

3. Configurer l'index

Une fois les champs et les fonctions définis, créez un index pour la collection. Pour des raisons de simplicité, nous utilisons ici le type AUTOINDEX à titre d'exemple.

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

4. Création de la collection

Utilisez le schéma et l'index définis pour créer une nouvelle collection. Dans cet exemple, nous allons créer une collection nommée Demo.

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

5. Insérer des données

Vous pouvez maintenant insérer des données brutes directement dans Milvus - il n'est pas nécessaire de générer des embeddings manuellement.

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

6. Effectuer une recherche vectorielle

Après avoir inséré des données, vous pouvez effectuer des recherches directement à l'aide de requêtes de texte brut. Milvus convertit automatiquement votre requête en un embedding, effectue une recherche de similarité par rapport aux vecteurs stockés et renvoie les meilleures correspondances.

# 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)
# Example output:
# data: ["[{'id': 1, 'distance': 0.8821347951889038, 'entity': {'document': 'Milvus simplifies semantic search through embeddings.'}}]"]

Pour plus de détails sur la recherche vectorielle, voir : Recherche vectorielle de base et API de requête.

Démarrer avec Milvus 2.6

Avec Data-in, Data-out, Milvus 2.6 fait passer la simplicité de la recherche vectorielle au niveau supérieur. En intégrant les fonctions d'intégration et de reclassement directement dans Milvus, vous n'avez plus besoin de gérer un prétraitement externe ou de maintenir des services d'intégration distincts.

Prêt à l'essayer ? Installez Milvus 2.6 dès aujourd'hui et découvrez par vous-même la puissance de Data-in, Data-out.

Vous avez des questions ou souhaitez approfondir une fonctionnalité ? Rejoignez notre canal Discord ou déposez des questions sur GitHub. Vous pouvez également réserver une session individuelle de 20 minutes pour obtenir des informations, des conseils et des réponses à vos questions dans le cadre des Milvus Office Hours.

En savoir plus sur les fonctionnalités de Milvus 2.6

• Présentation de Milvus 2.6 : Recherche vectorielle abordable à l'échelle du milliard

• Déchiquetage JSON dans Milvus : filtrage JSON 88,9 fois plus rapide et flexible

• Déverrouiller la véritable recherche au niveau de l'entité : Nouvelles fonctionnalités Array-of-Structs et MAX_SIM dans Milvus

• MinHash LSH dans Milvus : l'arme secrète pour lutter contre les doublons dans les données de formation LLM

• La compression vectorielle à l'extrême : comment Milvus répond à 3× plus de requêtes avec RaBitQ

• Les benchmarks mentent - les bases de données vectorielles méritent un vrai test

• Nous avons remplacé Kafka/Pulsar par un Woodpecker pour Milvus

• La recherche vectorielle dans le monde réel : comment filtrer efficacement sans tuer le rappel ?