Erste Schritte mit dem Milvus JavaScript Client
Milvus ist eine robuste Open-Source-Datenbank für Vektorsuche. Seine Fähigkeit, für nahezu jede Last horizontal zu skalieren, macht es zur besten Wahl für Machine-Learning-Deployments. Es bietet außerdem erstklassige Tools, einschließlich solcher für JavaScript-Clients. In diesem Beitrag zeigen wir Ihnen, wie Sie mit Milvus und JavaScript loslegen.
Das Milvus node.js SDK(Client) ermöglicht es Ihnen, flexible und leistungsstarke Datenverarbeitungsfunktionen direkt in Ihre JavaScript-Umgebung zu integrieren. Es verwendet Node.js, um eine Verbindung zu einem Milvus-Server herzustellen, und bietet Ihnen vollständigen Zugriff auf alle Datenbankoperationen. Sie können den Client verwenden, um Collections zu erstellen, Daten einzufügen, Indizes zu erstellen, Abfragen und Suchen durchzuführen und mehr.
Wir beginnen mit der Einrichtung der Umgebung, die zum Ausführen des Codes erforderlich ist, einschließlich einer lokalen Serverinstanz. Sobald alles läuft, fahren Sie mit der Verbindung zur Milvus-Datenbank fort. Dieser grundlegende Schritt stellt sicher, dass Sie an die umfangreichen Ressourcen angebunden sind, die Milvus bietet.
Dann erstellen Sie eine Collection in Milvus. Sobald Ihre Collection eingerichtet ist, kommen wir schließlich zum Kern der Datenoperationen: dem Einfügen und Abfragen von Daten.
Legen wir los.
Voraussetzungen
Bevor Sie beginnen, müssen einige Dinge auf Ihrem Entwicklungssystem installiert sein.
Wir verwenden für dieses Tutorial Milvus Lite, daher benötigen Sie Python 3.8 oder höher. Sie benötigen außerdem Node.js Version 12 oder höher, npm Version 12 oder höher oder yarn, um Pakete zu installieren.
Nachdem Sie alles vorbereitet haben, installieren und starten wir Milvus Lite und den JavaScript Client.
Milvus Lite installieren und ausführen
Eine bewährte Vorgehensweise zum Ausführen von Python-Anwendungen wie Milvus Lite ist die Verwendung einer virtuellen Umgebung. Erstellen Sie eine Umgebung, aktivieren Sie sie und aktualisieren Sie 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
Installieren Sie als Nächstes die milvus-Bibliothek von 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]$
Starten Sie schließlich Ihren 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 ...
Das Milvus node.js SDK(Client) installieren
Initialisieren Sie zunächst npm in Ihrem Arbeitsverzeichnis.
[egoebelbecker@ares examples]$ npm init
[egoebelbecker@ares examples]$ npm install @zilliz/milvus2-sdk-node
Jetzt können Sie Code schreiben!
Erste Schritte mit Milvus und JavaScript
Nachdem du Milvus und JavaScript installiert hast, bist du bereit, Milvus und JavaScript auszuführen.
Mit Milvus verbinden
Du kannst über die Klasse MilvusClient eine Verbindung zu Milvus herstellen und mit Milvus kommunizieren.
Milvus bietet mehrere Optionen zum Verbinden, wie Benutzername, Passwort und Serveradresse. Da du Milvus Lite verwendest, musst du nur angeben, wohin die Verbindung hergestellt werden soll.
Erstelle einen MilvusClient und prüfe das Feld connectStatus, um sicherzustellen, dass die Verbindung besteht:
import { MilvusClient } from '@zilliz/milvus2-sdk-node';
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
console.log("Connection status: " + milvusClient.connectStatus)
Hier ist die Ausgabe:
Connection status: 1
Eine Datenbank erstellen
Dein Server ist leer, also beginnen wir mit dem Erstellen einer Datenbank.
Die meisten Milvus-Javascript-API-Aufrufe beinhalten eine Netzwerkanfrage, daher geben sie ein Promise zurück. Außerdem ist nicht garantiert, dass sie in der Reihenfolge ausgeführt werden, in der du sie in deinem Code aufführst. Daher musst du auf das Timing achten und Tools wie Promise-Chaining, Codeblöcke und await verwenden, um sicherzustellen, dass Funktionen in der von dir erwarteten Reihenfolge ausgeführt werden.
Um den Code leichter lesbar zu machen, verwende ich einzelne Codeblöcke und gebe das Promise aus, wenn es abgeschlossen ist. Ich werde außerdem bei Bedarf await als „Brute-Force“-Ansatz verwenden, um sicherzustellen, dass Code in der richtigen Reihenfolge ausgeführt wird.
Für Produktionscode würdest du wahrscheinlich einen anderen Ansatz verwenden.
Dieser Code erstellt eine Datenbank mit createDatabase und verwendet await, damit der Code erst fortfährt, wenn der Vorgang abgeschlossen ist. Anschließend überprüft er, dass die neue Datenbank vorhanden ist, indem listDatabases aufgerufen wird.
CreateDatabase benötigt nur einen Datenbanknamen.
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);
})();
Die Ergebnisse sind wie folgt:
Connection status: 1
Database is created { error_code: 'Success', reason: '' }
list databases {
db_names: [ 'my_db', 'default' ],
status: { error_code: 'Success', reason: '' }
}
Eine Collection erstellen
Als Nächstes ist es an der Zeit, eine Collection zu erstellen, damit du ihr einige Daten hinzufügen kannst.
Bevor du eine Collection erstellst oder verwendest, musst du die Datenbank usen, die sie enthält. Nach dem Verbinden verwendet dieses Skript also uses my_db.
Dann erstellt es die neue Collection mit createCollection und prüft sie mit describeCollection. Eine neue Collection benötigt ein Schema mit Datentypen, daher musst du DataType in das Skript importieren.
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);
})();
Das Skript wird erfolgreich ausgeführt und gibt Informationen über die neue Sammlung aus:
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'
}
Daten hinzufügen und abrufen
Jetzt ist es an der Zeit, einige Daten zur Sammlung hinzuzufügen.
Zuerst benötigen wir die Daten. Normalerweise liest dein Code Daten von irgendwo ein oder stellt sie zusammen, aber du verwendest hier einige fest codierte Werte.
Nachdem ein Array von Werten deklariert wurde, verwendet dieses Skript eine InsertReq, um sie per Namen in die neue Sammlung einzufügen:
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);
})();
Die API gibt Informationen darüber zurück, was Sie eingefügt haben:
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'
}
Jetzt haben Sie einige Daten, die Sie abfragen können. Aber bevor Sie begonnen haben, Abfragen in der Produktion auszuführen, würden Sie wahrscheinlich einen Index hinzufügen zu Ihrer Sammlung. Dies fügt einen Index für das Feld vector hinzu:
const createIndex = await milvusClient.createIndex({
collection_name: 'sample_collection',
field_name: 'vector',
metric_type: 'L2',
});
Um diesen Code auszuführen, muss Ihr Skript weiterhin eine Verbindung herstellen und die zugehörige Datenbank verwenden.
Schließlich können Sie eine Abfrage ausführen, die in einem beliebigen von Milvus unterstützten Ausdruck oder einer beliebigen Abfrage geschrieben ist. Bei dieser werden Elemente einfach nach Alter gefiltert.
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);
})();
Hier ist das Ergebnis:
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' }
]
}
Vektoren suchen
Sobald Ihre Collection in den Speicher geladen ist, können Sie darauf eine Vektorähnlichkeitssuche durchführen.
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);
})();
Hier ist das Ergebnis:
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'
}
]
}
Zusammenfassung
Wir haben eine Entwicklungsumgebung für die Arbeit mit Milvus und Milvus JavaScript eingerichtet. Wir haben uns mit einem Server verbunden, eine Datenbank und eine Collection erstellt, Daten eingefügt und abgerufen sowie Ähnlichkeits-Vektorsuchen durchgeführt. Wie Sie gesehen haben, könnte die Arbeit mit Vektordaten in JavaScript mit Milvus nicht einfacher sein!
Fügen Sie Ihren Web-Apps noch heute die Leistungsfähigkeit der Vektorsuche hinzu! Wenn Sie schon dabei sind, werfen Sie einen Blick auf eine kostenlose Testversion von Zilliz Cloud und sehen Sie, wie Sie in wenigen Minuten einen cloudfähigen, zuverlässigen und leistungsstarken Milvus-Cluster zum Laufen bringen können.
Über den Autor
Dieser Beitrag wurde von Eric Goebelbecker geschrieben. Eric arbeitet seit 25 Jahren auf den Finanzmärkten in New York City und entwickelt Infrastruktur für Marktdaten- und Financial Information Exchange (FIX)-Protokollnetzwerke. Er spricht gerne darüber, was Teams effektiv macht (oder weniger effektiv!).
Weiterlesen
Zilliz Cloud Just Landed in Claude Code
The Zilliz Cloud Plugin brings the full power of Zilliz Cloud directly into your Claude Code terminal as natural-language conversations.
Zilliz Cloud Now Available in AWS Europe (Ireland)
Zilliz Cloud launches in AWS eu-west-1 (Ireland) — bringing low-latency vector search, EU data residency, and full GDPR-ready infrastructure to European AI teams. Now live across 30 regions on five cloud providers.
Why I’m Against Claude Code’s Grep-Only Retrieval? It Just Burns Too Many Tokens
Learn how vector-based code retrieval cuts Claude Code token consumption by 40%. Open-source solution with easy MCP integration. Try claude-context today.