Bien démarrer avec le client JavaScript Milvus
Milvus est une base de données open source robuste pour la recherche vectorielle. Sa capacité à évoluer horizontalement pour presque n’importe quelle charge en fait le meilleur choix pour les déploiements de machine learning. Elle propose également des outils de premier ordre, notamment pour les clients JavaScript. Dans cet article, nous vous montrerons comment démarrer avec Milvus et JavaScript.
Le SDK node.js Milvus (Client) vous permet de créer des capacités de gestion de données flexibles et puissantes directement dans votre environnement JavaScript. Il utilise Node.js pour se connecter à un serveur Milvus, vous donnant un accès complet à toutes les opérations de base de données. Vous pouvez utiliser le client pour créer des collections, insérer des données, créer des index, effectuer des requêtes et des recherches, et plus encore.
Nous commencerons par configurer l’environnement nécessaire pour exécuter le code, y compris une instance de serveur locale. Une fois que tout sera opérationnel, vous passerez à la connexion à la base de données Milvus. Cette étape fondamentale garantit que vous êtes connecté aux vastes ressources offertes par Milvus.
Ensuite, vous créerez une collection dans Milvus. Une fois votre collection configurée, nous entrerons enfin dans le cœur des opérations sur les données : l’insertion et l’interrogation des données.
Commençons.
Prérequis
Avant de commencer, vous aurez besoin de quelques éléments installés sur votre système de développement.
Nous utiliserons Milvus Lite pour ce tutoriel, vous aurez donc besoin de Python 3.8 ou supérieur. Vous aurez également besoin de Node.js version 12 ou supérieure, de npm version 12 ou supérieure, ou de yarn, pour installer les packages.
Après avoir tout préparé, installons et exécutons Milvus Lite et JavaScript Client.
Installer et exécuter Milvus Lite
Une bonne pratique pour exécuter des applications Python comme Milvus Lite consiste à utiliser un environnement virtuel. Créez un environnement, activez-le et mettez à niveau pip.
[egoebelbecker@ares examples]$ python3 -m venv ./venv
[egoebelbecker@ares examples]$ source venv/bin/activate
(venv) [egoebelbecker@ares examples]$ pip install --upgrade pip
Requirement already satisfied: pip in ./venv/lib64/python3.11/site-packages (22.3.1)
Collecting pip
Using cached pip-23.2-py3-none-any.whl (2.1 MB)
Installing collected packages: pip
Attempting uninstall: pip
Found existing installation: pip 22.3.1
Uninstalling pip-22.3.1:
Successfully uninstalled pip-22.3.1
Successfully installed pip-23.2
Ensuite, installez la bibliothèque milvus depuis PyPi.
(venv) [egoebelbecker@ares examples]$ pip install milvus
Collecting milvus
Obtaining dependency information for milvus from https://files.pythonhosted.org/packages/c1/a6/599ba1f8615e6ec73208ab614f5daf7ab27097070fbbd1715a1b5cc5e578/milvus-2.2.11-py3-none-manylinux2014_x86_64.whl.metadata
Downloading milvus-2.2.11-py3-none-manylinux2014_x86_64.whl.metadata (6.7 kB)
Using cached milvus-2.2.11-py3-none-manylinux2014_x86_64.whl (51.7 MB)
Installing collected packages: milvus
Successfully installed milvus-2.2.11
(venv) [egoebelbecker@ares examples]$
Enfin, lancez votre serveur.
(venv) [egoebelbecker@ares examples]$ milvus-server
__ _________ _ ____ ______
/ |/ / _/ /| | / / / / / __/
/ /|_/ // // /_| |/ / /_/ /\ \
/_/ /_/___/____/___/\____/___/ {Lite}
Welcome to use Milvus!
Version: v2.2.11-lite
Process: 505236
Started: 2023-07-20 14:18:37
Config: /home/egoebelbecker/.milvus.io/milvus-server/2.2.11/configs/milvus.yaml
Logs: /home/egoebelbecker/.milvus.io/milvus-server/2.2.11/logs
Ctrl+C to exit ...
Installer le SDK node.js Milvus (Client)
Tout d’abord, initialisez npm dans votre répertoire de travail.
[egoebelbecker@ares examples]$ npm init
[egoebelbecker@ares examples]$ npm install @zilliz/milvus2-sdk-node
Maintenant, vous êtes prêt à écrire du code !
Premiers pas avec Milvus et JavaScript
Après avoir installé Milvus et JavaScript, vous êtes prêt à exécuter Milvus et JavaScript.
Se connecter à Milvus
Vous pouvez vous connecter à Milvus et communiquer avec lui via la classe MilvusClient.
Milvus offre plusieurs options de connexion, telles que le nom d’utilisateur, le mot de passe et l’adresse du serveur. Puisque vous utilisez Milvus Lite, il vous suffit de lui indiquer où se connecter.
Créez un MilvusClient et vérifiez le champ connectStatus pour vous assurer qu’il est connecté :
import { MilvusClient } from '@zilliz/milvus2-sdk-node';
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
console.log("Connection status: " + milvusClient.connectStatus)
Voici la sortie :
Connection status: 1
Créer une base de données
Votre serveur est vide, alors commençons par créer une base de données.
La plupart des appels à l’API Javascript de Milvus impliquent une requête réseau, ils renvoient donc une promesse. Il n’est pas non plus garanti qu’ils s’exécutent dans l’ordre dans lequel vous les listez dans votre code, vous devez donc faire attention au timing et utiliser des outils comme le chaînage de promesses, les blocs de code et await pour vous assurer que les fonctions s’exécutent dans l’ordre attendu.
Pour rendre le code plus facile à lire, j’utiliserai des blocs de code individuels et j’afficherai la promesse lorsqu’elle se termine. J’utiliserai également await lorsque nécessaire comme approche « brute force » pour garantir que le code s’exécute dans le bon ordre.
Pour du code de production, vous utiliseriez probablement une approche différente.
Ce code crée une base de données avec createDatabase, en utilisant await pour empêcher le code de continuer tant que l’opération n’est pas terminée. Ensuite, il vérifie que la nouvelle base de données existe en appelant listDatabases.
CreateDatabase n’a besoin que d’un nom de base de données.
import { MilvusClient } from '@zilliz/milvus2-sdk-node';
(async () => {
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
console.log("Connection status: " + milvusClient.connectStatus)
const createDb = await milvusClient.createDatabase({ db_name: 'my_db' });
console.log('Database is created', createDb);
const listDatabases = await milvusClient.listDatabases();
console.log('list databases', listDatabases);
})();
Les résultats sont les suivants :
Connection status: 1
Database is created { error_code: 'Success', reason: '' }
list databases {
db_names: [ 'my_db', 'default' ],
status: { error_code: 'Success', reason: '' }
}
Créer une collection
Ensuite, il est temps de créer une collection afin de pouvoir y ajouter des données.
Avant de créer ou d’utiliser une collection, vous devez utiliser la base de données qui la contient. Ainsi, après la connexion, ce script utilise my_db.
Ensuite, il crée la nouvelle collection avec createCollection et la vérifie avec describeCollection. Une nouvelle collection a besoin d’un schéma avec des types de données, vous devez donc importer DataType dans le script.
import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';
(async () => {
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
console.log('Connection status: ' + milvusClient.connectStatus);
await milvusClient.use({ db_name: 'my_db' });
const create = await milvusClient.createCollection({
collection_name: 'sample_collection',
fields: [
{
name: 'age',
description: 'ID field',
data_type: DataType.Int64,
is_primary_key: true,
autoID: true,
},
{
name: 'vector',
description: 'Vector field',
data_type: DataType.FloatVector,
dim: 8,
},
{ name: 'height', description: 'int64 field', data_type: DataType.Int64 },
{
name: 'name',
description: 'VarChar field',
data_type: DataType.VarChar,
max_length: 128,
},
],
});
console.log('Create collection is finished.', create);
await milvusClient.describeCollection({ collection_name: 'sample_collection'});
console.log('describe collection', describeCollection);
})();
Le script réussit avec des informations sur la nouvelle collection :
Connection status: 1
new Database is using { error_code: 'Success', reason: '' }
Create collection is finished. { error_code: 'Success', reason: '' }
describe collection {
virtual_channel_names: [ 'by-dev-rootcoord-dml_1_443014985196255045v0' ],
physical_channel_names: [ 'by-dev-rootcoord-dml_1' ],
aliases: [],
start_positions: [],
properties: [],
status: { error_code: 'Success', reason: '' },
schema: {
fields: [ [Object], [Object], [Object], [Object] ],
name: 'sample_collection',
description: '',
autoID: false,
enable_dynamic_field: false
},
collectionID: '443014985196255045',
created_timestamp: '443015720996700166',
created_utc_timestamp: '1689970859515',
shards_num: 1,
consistency_level: 'Bounded',
collection_name: 'sample_collection',
db_name: 'my_db',
num_partitions: '1'
}
Ajouter et récupérer des données
Il est maintenant temps d’ajouter des données à la collection.
Tout d’abord, nous avons besoin des données. Habituellement, votre code lit ou assemble des données depuis quelque part, mais vous allez utiliser des valeurs codées en dur.
Après avoir déclaré un tableau de valeurs, ce script utilise un InsertReq pour les insérer par nom dans la nouvelle collection :
import { MilvusClient, InsertReq } from '@zilliz/milvus2-sdk-node';
(async () => {
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
console.log('Connection status: ' + milvusClient.connectStatus);
const useDb = await milvusClient.use({ db_name: 'my_db' });
console.log('new Database is using', useDb);
const vectorsData = [
{
vector: [
0.11878310581111173, 0.9694947902934701, 0.16443679307243175,
0.5484226189097237, 0.9839246709011924, 0.5178387104937776,
0.8716926129208069, 0.5616972243831446,
],
height: 20405,
name: 'zlnmh',
},
{
vector: [
0.9992090731236536, 0.8248790611809487, 0.8660083940881405,
0.09946359318481224, 0.6790698063908669, 0.5013786801063624,
0.795311915725105, 0.9183033261617566,
],
height: 93773,
name: '5lr9y',
},
{
vector: [
0.8761291569818763, 0.07127366044153227, 0.775648976160332,
0.5619757601304878, 0.6076543120476996, 0.8373907516027586,
0.8556140171597648, 0.4043893119391049,
],
height: 85122,
name: 'nes0j',
},
{
vector: [
0.5849602436079879, 0.5108258101682586, 0.8250884731578105,
0.7996354835509332, 0.8207766774911736, 0.38133662902290566,
0.7576720055508186, 0.4393152967662368,
],
height: 92037,
name: 'ct2li',
},
{
vector: [
0.3768133716738886, 0.3823259261020866, 0.7906232829855262,
0.31693696726284193, 0.3731715403499176, 0.3300751870649885,
0.22353556137796238, 0.38062799545615444,
],
height: 31400,
name: '6ghrg',
},
{
vector: [
0.0007531778212483964, 0.12941566118774994, 0.9340164428788116,
0.3795768837758642, 0.4532443258064389, 0.596455163143,
0.9529469158782906, 0.7692465408044873,
],
height: 1778,
name: 'sb7mt',
},
];
const params: InsertReq = {
collection_name: 'sample_collection',
fields_data: vectorsData,
};
// insert data into collection
const insert = await milvusClient.insert(params);
console.log('Inserted data:', insert);
})();
L’API renvoie des informations sur ce que vous avez inséré :
Connection status: 1
new Database is using { error_code: 'Success', reason: '' }
Inserted data: {
succ_index: [ 0, 1, 2, 3, 4, 5 ],
err_index: [],
status: { error_code: 'Success', reason: '' },
IDs: { int_id: { data: [Array] }, id_field: 'int_id' },
acknowledged: false,
insert_cnt: '6',
delete_cnt: '0',
upsert_cnt: '0',
timestamp: '443015922585698312'
}
Vous disposez maintenant de données à interroger. Mais avant de commencer à exécuter des requêtes en production, vous devriez probablement ajouter un index à votre collection. Cela ajoute un index sur le champ vector :
const createIndex = await milvusClient.createIndex({
collection_name: 'sample_collection',
field_name: 'vector',
metric_type: 'L2',
});
Pour exécuter ce code, votre script doit toujours se connecter et utiliser la base de données associée.
Enfin, vous pouvez exécuter une requête écrite dans n’importe quelle expression ou requête prise en charge par Milvus. Pour celle-ci, elle filtre simplement les éléments en fonction de l’âge.
import { MilvusClient } from '@zilliz/milvus2-sdk-node';
(async () => {
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
const useDb = await milvusClient.use({ db_name: 'my_db' });
console.log('new Database is using', useDb);
const load = await milvusClient.loadCollectionSync({ collection_name: 'sample_collection' });
const query = await milvusClient.query({
collection_name: 'sample_collection',
filter: 'age > 0',
output_fields: ['age', 'vector'],
limit: 100,
});
console.log('query result', query);
})();
Voici le résultat :
new Database is using { error_code: 'Success', reason: '' }
Query time: 235.806ms
query result {
status: { error_code: 'Success', reason: '' },
data: [
{ vector: [Array], age: '443014985196258910' },
{ vector: [Array], age: '443014985196258911' },
{ vector: [Array], age: '443014985196258912' },
{ vector: [Array], age: '443014985196258913' },
{ vector: [Array], age: '443014985196258914' },
{ vector: [Array], age: '443014985196258915' }
]
}
Rechercher des vecteurs
Une fois votre collection chargée en mémoire, vous pouvez effectuer une recherche de similarité vectorielle dessus.
import { MilvusClient } from '@zilliz/milvus2-sdk-node';
(async () => {
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
const useDb = await milvusClient.use({ db_name: 'my_db' });
console.log('new Database is using', useDb);
const load = await milvusClient.loadCollectionSync({ collection_name: 'sample_collection' });
const query = await milvusClient.search({
collection_name: 'sample_collection',
vector: [1,2,3,4,5,6,7,8],
filter: 'age > 0',
output_fields: ['id', 'age'],
limit: 5,
});
console.log('query result', query);
})();
Voici le résultat :
Search result {
status: { error_code: 'Success', reason: '' },
results: [
{ score: 0, id: '442936641561652921', age: '442936641561652921' },
{
score: 1.0004949569702148,
id: '442936641561652924',
age: '442936641561652924'
},
{
score: 1.6779069900512695,
id: '442936641561652926',
age: '442936641561652926'
},
{
score: 1.7160398960113525,
id: '442936641561652922',
age: '442936641561652922'
},
{
score: 1.718210220336914,
id: '442936641561652925',
age: '442936641561652925'
}
]
}
Résumé
Nous avons configuré un environnement de développement pour travailler avec Milvus et le JavaScript Milvus. Nous nous sommes connectés à un serveur, avons créé une base de données et une collection, inséré des données et les avons récupérées, puis effectué des recherches vectorielles par similarité. Comme vous l’avez vu, travailler avec des données vectorielles en JavaScript avec Milvus ne pourrait pas être plus simple !
Ajoutez dès aujourd’hui la puissance de la recherche vectorielle à vos applications web ! Pendant que vous y êtes, jetez un œil à un essai gratuit de Zilliz Cloud et découvrez comment vous pouvez disposer en quelques minutes d’un cluster Milvus prêt pour le cloud, fiable et hautes performances.
À propos de l’auteur
Cet article a été rédigé par Eric Goebelbecker. Eric a travaillé sur les marchés financiers à New York pendant 25 ans, développant des infrastructures pour les données de marché et les réseaux de protocole d’échange d’informations financières (FIX). Il adore parler de ce qui rend les équipes efficaces (ou moins efficaces !).
Continuer à lire
Notion's Vector Search Is Excellent. Their Next Problem Is Harder.
Notion solved vector search scaling in two years. The next bottleneck — offline context engineering, unified data, and the real-time/offline gap — is harder.
The Real Bottlenecks in Autonomous Driving — And How AI Infrastructure Can Solve Them
Autonomous driving faces a data bottleneck. Learn how AI-native vector databases like Zilliz solve scale, cost, and insight challenges across AV pipelines.
Building RAG Pipelines for Real-Time Data with Cloudera and Milvus
explore how Cloudera can be integrated with Milvus to effectively implement some of the key functionalities of RAG pipelines.