Introduzione al client JavaScript di Milvus
Milvus è un solido database open-source per la ricerca vettoriale. La sua capacità di scalare orizzontalmente per quasi qualsiasi carico lo rende la scelta migliore per le distribuzioni di machine learning. Offre inoltre strumenti ai vertici della categoria, anche per i client JavaScript. In questo post, ti mostreremo come iniziare a usare Milvus e JavaScript.
Il Milvus node.js SDK(Client) ti consente di integrare funzionalità di gestione dei dati flessibili e potenti direttamente nel tuo ambiente JavaScript. Usa Node.js per connettersi a un server Milvus, offrendoti accesso completo a tutte le operazioni del database. Puoi usare il client per creare collection, inserire dati, creare indici, eseguire query e ricerche, e altro ancora.
Inizieremo configurando l’ambiente necessario per eseguire il codice, inclusa un’istanza server locale. Una volta operativi, passerai alla connessione al database Milvus. Questo passaggio fondamentale garantisce che tu sia collegato alle vaste risorse offerte da Milvus.
Poi creerai una collection in Milvus. Con la tua collection configurata, entreremo finalmente nel cuore delle operazioni sui dati: inserire ed eseguire query sui dati.
Cominciamo.
Prerequisiti
Prima di iniziare, dovrai avere installate alcune cose sul tuo sistema di sviluppo.
Useremo Milvus Lite per questo tutorial, quindi ti servirà Python 3.8 o superiore. Ti servirà anche Node.js versione 12 o superiore, npm versione 12 o superiore, oppure yarn, per installare i pacchetti.
Dopo aver preparato tutto, installiamo ed eseguiamo Milvus Lite e JavaScript Client.
Installare ed eseguire Milvus Lite
Una best practice per eseguire applicazioni Python come Milvus Lite è usare un ambiente virtuale. Crea un ambiente, attivalo e aggiorna 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
Successivamente, installa la libreria milvus da 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]$
Infine, esegui il tuo server.
(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 ...
Installare il Milvus node.js SDK(Client)
Per prima cosa, inizializza npm nella tua directory di lavoro.
[egoebelbecker@ares examples]$ npm init
[egoebelbecker@ares examples]$ npm install @zilliz/milvus2-sdk-node
Ora sei pronto a scrivere un po’ di codice!
Iniziare con Milvus e JavaScript
Dopo aver installato Milvus e JavaScript, sei pronto a eseguire Milvus e JavaScript.
Connettersi a Milvus
Puoi connetterti e comunicare con Milvus tramite la classe MilvusClient.
Milvus offre diverse opzioni per connettersi, come nome utente, password e indirizzo del server. Poiché stai usando Milvus Lite, devi solo indicargli dove connettersi.
Crea un MilvusClient e controlla il campo connectStatus per assicurarti che sia connesso:
import { MilvusClient } from '@zilliz/milvus2-sdk-node';
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
console.log("Connection status: " + milvusClient.connectStatus)
Ecco l’output:
Connection status: 1
Creare un database
Il tuo server è vuoto, quindi iniziamo creando un database.
La maggior parte delle chiamate API Javascript di Milvus comporta una richiesta di rete, quindi restituisce una promise. Inoltre, non è garantito che vengano eseguite nell’ordine in cui le elenchi nel codice, quindi devi prestare attenzione al timing e usare strumenti come il concatenamento delle promise, i blocchi di codice e await per assicurarti che le funzioni vengano eseguite nell’ordine previsto.
Per rendere il codice più facile da leggere, userò blocchi di codice individuali e stamperò la promise quando viene completata. Userò anche await quando necessario come approccio “brute force” per assicurarmi che il codice venga eseguito nell’ordine corretto.
Per il codice di produzione, probabilmente useresti un approccio diverso.
Questo codice crea un database con createDatabase, usando await per impedire al codice di procedere finché non è completo. Poi verifica che il nuovo database sia presente chiamando listDatabases.
CreateDatabase ha bisogno solo del nome di un database.
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);
})();
I risultati sono i seguenti:
Connection status: 1
Database is created { error_code: 'Success', reason: '' }
list databases {
db_names: [ 'my_db', 'default' ],
status: { error_code: 'Success', reason: '' }
}
Creare una collection
Successivamente, è il momento di creare una collection in modo da poterle aggiungere alcuni dati.
Prima di creare o usare una collection, devi usare il database che la contiene. Quindi, dopo la connessione, questo script usa my_db.
Poi crea la nuova collection con createCollection e la controlla con describeCollection. Una nuova collection ha bisogno di uno schema con tipi di dati, quindi devi importare DataType nello 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);
})();
Lo script riesce con informazioni sulla nuova raccolta:
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'
}
Aggiungere e recuperare dati
Ora è il momento di aggiungere alcuni dati alla raccolta.
Per prima cosa, abbiamo bisogno dei dati. Di solito, il tuo codice legge o assembla dati da qualche parte, ma userai alcuni valori codificati direttamente.
Dopo aver dichiarato un array di valori, questo script utilizza un InsertReq per insert per nome nella nuova raccolta:
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 restituisce informazioni su ciò che hai inserito:
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'
}
Ora hai dei dati da interrogare. Ma prima di iniziare a eseguire query in produzione, probabilmente aggiungeresti un indice alla tua collection. Questo aggiunge un indice sul campo vector:
const createIndex = await milvusClient.createIndex({
collection_name: 'sample_collection',
field_name: 'vector',
metric_type: 'L2',
});
Per eseguire questo codice, il tuo script deve comunque connettersi e usare il database associato.
Infine, puoi eseguire una query scritta in qualsiasi espressione o query supportata da Milvus. In questo caso, filtra semplicemente gli elementi in base all'età.
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);
})();
Ecco il risultato:
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' }
]
}
Cercare vettori
Una volta che la tua raccolta è caricata in memoria, puoi eseguire una ricerca di similarità vettoriale su di essa.
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);
})();
Ecco il risultato:
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'
}
]
}
Riepilogo
Abbiamo configurato un ambiente di sviluppo per lavorare con Milvus e Milvus JavaScript. Ci siamo connessi a un server, abbiamo creato un database e una raccolta, inserito dati e li abbiamo recuperati, ed eseguito ricerche vettoriali di similarità. Come hai visto, lavorare con dati vettoriali in JavaScript con Milvus non potrebbe essere più semplice!
Aggiungi oggi stesso la potenza della ricerca vettoriale alle tue app web! Già che ci sei, dai un'occhiata a una prova gratuita di Zilliz Cloud e scopri come puoi avere un cluster Milvus pronto per il cloud, affidabile e ad alte prestazioni, in esecuzione in pochi minuti.
Informazioni sull'autore
Questo post è stato scritto da Eric Goebelbecker. Eric ha lavorato nei mercati finanziari a New York City per 25 anni, sviluppando infrastrutture per i dati di mercato e reti basate sul protocollo Financial Information Exchange (FIX). Ama parlare di ciò che rende i team efficaci (o non così efficaci!).
Continua a leggere
DeepSeek-OCR Explained: Optical Compression for Scalable Long-Context and RAG Systems
Discover how DeepSeek-OCR uses visual tokens and Contexts Optical Compression to boost long-context LLM efficiency and reshape RAG performance.
Introducing Zilliz MCP Server: Natural Language Access to Your Vector Database
Developers can easily manage and query vector databases with natural language via Zilliz MCP Server in AI-native environments.
How to Build RAG with Milvus, QwQ-32B and Ollama
Hands-on tutorial on how to create a streamlined, powerful RAG pipeline that balances efficiency, accuracy, and scalability using the QwQ-32B and Milvus.