Primeros pasos con el cliente JavaScript de Milvus
Milvus es una robusta base de datos de código abierto para búsqueda vectorial. Su capacidad de escalar horizontalmente para casi cualquier carga la convierte en la mejor opción para implementaciones de aprendizaje automático. También cuenta con herramientas de primera clase, incluidas las de clientes JavaScript. En esta publicación, te mostraremos cómo empezar con Milvus y JavaScript.
El Milvus node.js SDK(Client) te permite crear capacidades de manejo de datos flexibles y potentes directamente en tu entorno JavaScript. Utiliza Node.js para conectarse a un servidor Milvus, proporcionándote acceso completo a todas las operaciones de la base de datos. Puedes usar el cliente para crear colecciones, insertar datos, crear índices, realizar consultas y búsquedas, y más.
Comenzaremos configurando el entorno necesario para ejecutar el código, incluida una instancia de servidor local. Una vez que estemos en marcha, pasarás a conectarte a la base de datos Milvus. Este paso fundamental garantiza que estés conectado a los vastos recursos que ofrece Milvus.
Luego crearás una colección en Milvus. Con tu colección configurada, finalmente entraremos en el núcleo de las operaciones de datos: insertar y consultar datos.
Comencemos.
Requisitos previos
Antes de empezar, necesitarás tener algunas cosas instaladas en tu sistema de desarrollo.
Usaremos Milvus Lite para este tutorial, así que necesitarás Python 3.8 o superior. También necesitarás Node.js versión 12 o superior, npm versión 12 o superior, o yarn, para instalar paquetes.
Después de preparar todo, instalemos y ejecutemos Milvus Lite y JavaScript Client.
Instalar y ejecutar Milvus Lite
Una buena práctica para ejecutar aplicaciones de Python como Milvus Lite es usar un entorno virtual. Crea un entorno, actívalo y actualiza 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
A continuación, instala la biblioteca milvus desde 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]$
Finalmente, ejecuta tu servidor.
(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 ...
Instalar el Milvus node.js SDK(Client)
Primero, inicializa npm en tu directorio de trabajo.
[egoebelbecker@ares examples]$ npm init
[egoebelbecker@ares examples]$ npm install @zilliz/milvus2-sdk-node
Ahora, ¡estás listo para escribir algo de código!
Primeros pasos con Milvus y JavaScript
Después de instalar Milvus y JavaScript, estás listo para ejecutar Milvus y JavaScript.
Conectarse a Milvus
Puedes conectarte y comunicarte con Milvus mediante la clase MilvusClient.
Milvus ofrece varias opciones para conectarse, como nombre de usuario, contraseña y dirección del servidor. Como estás usando Milvus Lite, solo necesitas indicarle dónde conectarse.
Crea un MilvusClient y verifica el campo connectStatus para asegurarte de que esté conectado:
import { MilvusClient } from '@zilliz/milvus2-sdk-node';
const milvusClient = new MilvusClient({
address: 'localhost:19530',
});
console.log("Connection status: " + milvusClient.connectStatus)
Aquí está la salida:
Connection status: 1
Crear una base de datos
Tu servidor está vacío, así que empecemos creando una base de datos.
La mayoría de las llamadas a la API de Milvus Javascript implican una solicitud de red, por lo que devuelven una promesa. Tampoco se garantiza que se ejecuten en el orden en que las enumeras en tu código, por lo que debes tener en cuenta el tiempo y usar herramientas como el encadenamiento de promesas, bloques de código y await para garantizar que las funciones se ejecuten en el orden esperado.
Para que el código sea más fácil de leer, usaré bloques de código individuales e imprimiré la promesa cuando se complete. También usaré await cuando sea necesario como un enfoque de "fuerza bruta" para garantizar que el código se ejecute en el orden correcto.
Para código de producción, probablemente usarías un enfoque diferente.
Este código crea una base de datos con createDatabase, usando await para evitar que el código continúe hasta que se complete. Luego verifica que la nueva base de datos exista llamando a listDatabases.
CreateDatabase solo necesita un nombre de base de datos.
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);
})();
Los resultados son los siguientes:
Connection status: 1
Database is created { error_code: 'Success', reason: '' }
list databases {
db_names: [ 'my_db', 'default' ],
status: { error_code: 'Success', reason: '' }
}
Crear una colección
A continuación, es momento de crear una colección para que puedas agregarle algunos datos.
Antes de crear o usar una colección, necesitas usar la base de datos que la contiene. Por lo tanto, después de conectarse, este script usa my_db.
Luego, crea la nueva colección con createCollection y la verifica con describeCollection. Una nueva colección necesita un esquema con tipos de datos, por lo que debes importar DataType en el 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);
})();
El script se ejecuta correctamente con información sobre la nueva colección:
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'
}
Agregar y recuperar datos
Ahora es el momento de agregar algunos datos a la colección.
Primero, necesitamos los datos. Normalmente, tu código lee o reúne datos de algún lugar, pero usarás algunos valores codificados.
Después de declarar un array de valores, este script utiliza una InsertReq para insertarlos por nombre en la nueva colección:
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);
})();
La API devuelve información sobre lo que insertaste:
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'
}
Ahora, tienes algunos datos para consultar. Pero antes de empezar a ejecutar consultas en producción, probablemente agregarías un índice a tu colección. Esto agrega un índice en el campo vector:
const createIndex = await milvusClient.createIndex({
collection_name: 'sample_collection',
field_name: 'vector',
metric_type: 'L2',
});
Para ejecutar este código, tu script aún necesita conectarse y usar la base de datos asociada.
Finalmente, puedes ejecutar una consulta escrita en cualquier expresión o consulta compatible con Milvus. En esta, simplemente filtra elementos según la edad.
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);
})();
Aquí está el resultado:
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' }
]
}
Buscar vectores
Una vez que tu colección esté cargada en memoria, puedes realizar una búsqueda de similitud vectorial en ella.
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);
})();
Este es el resultado:
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'
}
]
}
Resumen
Hemos configurado un entorno de desarrollo para trabajar con Milvus y Milvus JavaScript. Nos conectamos a un servidor, creamos una base de datos y una colección, insertamos datos y los recuperamos, y realizamos búsquedas vectoriales de similitud. Como has visto, ¡trabajar con datos vectoriales en JavaScript con Milvus no podría ser más sencillo!
¡Añade hoy mismo el poder de la búsqueda vectorial a tus aplicaciones web! Ya que estás en ello, echa un vistazo a una prueba gratuita de Zilliz Cloud y descubre cómo puedes tener un clúster de Milvus listo para la nube, fiable y de alto rendimiento funcionando en minutos.
Acerca del autor
Esta publicación fue escrita por Eric Goebelbecker. Eric ha trabajado en los mercados financieros de la ciudad de Nueva York durante 25 años, desarrollando infraestructura para datos de mercado y redes del protocolo de intercambio de información financiera (FIX). Le encanta hablar sobre qué hace que los equipos sean eficaces (¡o no tan eficaces!).
Sigue leyendo
Build Multimodal Search for 3D Assets with Tripo and Zilliz Cloud
Generate 3D assets with Tripo, then search them by text, image, and metadata with multimodal embeddings and Zilliz Cloud.
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.
Vector Databases vs. Time Series Databases
Use a vector database for similarity search and semantic relationships; use a time series database for tracking value changes over time.