@vectorstores/milvus 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) vectorstores contributors 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,184 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@vectorstores/core');
+var env = require('@vectorstores/env');
+var milvus2SdkNode = require('@zilliz/milvus2-sdk-node');
+
+function parseScalarFilters(scalarFilters) {
+    const condition = scalarFilters.condition ?? "and";
+    const filters = [];
+    for (const filter of scalarFilters.filters){
+        switch(filter.operator){
+            case "==":
+            case "!=":
+                {
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} "${core.parsePrimitiveValue(filter.value)}"`);
+                    break;
+                }
+            case "in":
+                {
+                    const filterValue = core.parseArrayValue(filter.value).map((v)=>`"${v}"`).join(", ");
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} [${filterValue}]`);
+                    break;
+                }
+            case "nin":
+                {
+                    // Milvus does not support `nin` operator, so we need to manually check every value
+                    // Expected: not metadata["key"] != "value1" and not metadata["key"] != "value2"
+                    const filterStr = core.parseArrayValue(filter.value).map((v)=>`metadata["${filter.key}"] != "${v}"`).join(" && ");
+                    filters.push(filterStr);
+                    break;
+                }
+            case "<":
+            case "<=":
+            case ">":
+            case ">=":
+                {
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} ${core.parsePrimitiveValue(filter.value)}`);
+                    break;
+                }
+            default:
+                throw new Error(`Operator ${filter.operator} is not supported.`);
+        }
+    }
+    return filters.join(` ${condition} `);
+}
+class MilvusVectorStore extends core.BaseVectorStore {
+    constructor(init){
+        super(init), this.storesText = true, this.isEmbeddingQuery = false, this.flatMetadata = true, this.collectionInitialized = false;
+        if (init?.milvusClient) {
+            this.milvusClient = init.milvusClient;
+        } else {
+            const configOrAddress = init?.params?.configOrAddress ?? env.getEnv("MILVUS_ADDRESS");
+            const ssl = init?.params?.ssl ?? env.getEnv("MILVUS_SSL") === "true";
+            const username = init?.params?.username ?? env.getEnv("MILVUS_USERNAME");
+            const password = init?.params?.password ?? env.getEnv("MILVUS_PASSWORD");
+            if (!configOrAddress) {
+                throw new Error("Must specify MILVUS_ADDRESS via env variable.");
+            }
+            this.milvusClient = new milvus2SdkNode.MilvusClient(configOrAddress, ssl, username, password, init?.params?.channelOptions);
+        }
+        this.collectionName = init?.collection ?? "llamacollection";
+        this.idKey = init?.idKey ?? "id";
+        this.contentKey = init?.contentKey ?? "content";
+        this.metadataKey = init?.metadataKey ?? "metadata";
+        this.embeddingKey = init?.embeddingKey ?? "embedding";
+    }
+    client() {
+        return this.milvusClient;
+    }
+    async createCollection() {
+        await this.milvusClient.createCollection({
+            collection_name: this.collectionName,
+            fields: [
+                {
+                    name: this.idKey,
+                    data_type: milvus2SdkNode.DataType.VarChar,
+                    is_primary_key: true,
+                    max_length: 200
+                },
+                {
+                    name: this.embeddingKey,
+                    data_type: milvus2SdkNode.DataType.FloatVector,
+                    dim: 1536
+                },
+                {
+                    name: this.contentKey,
+                    data_type: milvus2SdkNode.DataType.VarChar,
+                    max_length: 9000
+                },
+                {
+                    name: this.metadataKey,
+                    data_type: milvus2SdkNode.DataType.JSON
+                }
+            ]
+        });
+        await this.milvusClient.createIndex({
+            collection_name: this.collectionName,
+            field_name: this.embeddingKey
+        });
+    }
+    async ensureCollection() {
+        if (!this.collectionInitialized) {
+            await this.milvusClient.connectPromise;
+            // Check collection exists
+            const isCollectionExist = await this.milvusClient.hasCollection({
+                collection_name: this.collectionName
+            });
+            if (!isCollectionExist.value) {
+                await this.createCollection();
+            }
+            await this.milvusClient.loadCollectionSync({
+                collection_name: this.collectionName
+            });
+            this.collectionInitialized = true;
+        }
+    }
+    async add(nodes) {
+        await this.ensureCollection();
+        const result = await this.milvusClient.insert({
+            collection_name: this.collectionName,
+            data: nodes.map((node)=>{
+                const metadata = core.nodeToMetadata(node, true, this.contentKey, this.flatMetadata);
+                const entry = {
+                    [this.idKey]: node.id_,
+                    [this.embeddingKey]: node.getEmbedding(),
+                    [this.contentKey]: node.getContent(core.MetadataMode.NONE),
+                    [this.metadataKey]: metadata
+                };
+                return entry;
+            })
+        });
+        if (!result.IDs) {
+            return [];
+        }
+        if ("int_id" in result.IDs) {
+            return result.IDs.int_id.data.map((i)=>String(i));
+        }
+        return result.IDs.str_id.data.map((s)=>String(s));
+    }
+    async delete(refDocId, deleteOptions) {
+        await this.ensureCollection();
+        await this.milvusClient.delete({
+            ids: [
+                refDocId
+            ],
+            collection_name: this.collectionName,
+            ...deleteOptions
+        });
+    }
+    toMilvusFilter(filters) {
+        if (!filters) return undefined;
+        // TODO: Milvus also support standard filters, we can add it later
+        return parseScalarFilters(filters);
+    }
+    async query(query, _options) {
+        await this.ensureCollection();
+        const found = await this.milvusClient.search({
+            collection_name: this.collectionName,
+            limit: query.similarityTopK,
+            vector: query.queryEmbedding,
+            filter: this.toMilvusFilter(query.filters)
+        });
+        const nodes = [];
+        const similarities = [];
+        const ids = [];
+        found.results.forEach((result)=>{
+            const node = core.metadataDictToNode(result.metadata);
+            node.setContent(result.content);
+            nodes.push(node);
+            similarities.push(result.score);
+            ids.push(String(result.id));
+        });
+        return {
+            nodes,
+            similarities,
+            ids
+        };
+    }
+    async persist() {
+    // no need to do anything
+    }
+}
+
+exports.MilvusVectorStore = MilvusVectorStore;

package/dist/index.d.cts

@@ -0,0 +1,42 @@
+import { ChannelOptions } from '@grpc/grpc-js';
+import { BaseVectorStore, VectorStoreBaseParams, BaseNode, Metadata, MetadataFilters, VectorStoreQuery, VectorStoreQueryResult } from '@vectorstores/core';
+import { MilvusClient, ClientConfig, DeleteReq } from '@zilliz/milvus2-sdk-node';
+
+declare class MilvusVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    isEmbeddingQuery?: boolean;
+    private flatMetadata;
+    private milvusClient;
+    private collectionInitialized;
+    private collectionName;
+    private idKey;
+    private contentKey;
+    private metadataKey;
+    private embeddingKey;
+    constructor(init?: Partial<{
+        milvusClient: MilvusClient;
+    }> & VectorStoreBaseParams & {
+        params?: {
+            configOrAddress: ClientConfig | string;
+            ssl?: boolean;
+            username?: string;
+            password?: string;
+            channelOptions?: ChannelOptions;
+        };
+        collection?: string;
+        idKey?: string;
+        contentKey?: string;
+        metadataKey?: string;
+        embeddingKey?: string;
+    });
+    client(): MilvusClient;
+    private createCollection;
+    private ensureCollection;
+    add(nodes: BaseNode<Metadata>[]): Promise<string[]>;
+    delete(refDocId: string, deleteOptions?: Omit<DeleteReq, "ids">): Promise<void>;
+    toMilvusFilter(filters?: MetadataFilters): string | undefined;
+    query(query: VectorStoreQuery, _options?: object): Promise<VectorStoreQueryResult>;
+    persist(): Promise<void>;
+}
+
+export { MilvusVectorStore };

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import { ChannelOptions } from '@grpc/grpc-js';
+import { BaseVectorStore, VectorStoreBaseParams, BaseNode, Metadata, MetadataFilters, VectorStoreQuery, VectorStoreQueryResult } from '@vectorstores/core';
+import { MilvusClient, ClientConfig, DeleteReq } from '@zilliz/milvus2-sdk-node';
+
+declare class MilvusVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    isEmbeddingQuery?: boolean;
+    private flatMetadata;
+    private milvusClient;
+    private collectionInitialized;
+    private collectionName;
+    private idKey;
+    private contentKey;
+    private metadataKey;
+    private embeddingKey;
+    constructor(init?: Partial<{
+        milvusClient: MilvusClient;
+    }> & VectorStoreBaseParams & {
+        params?: {
+            configOrAddress: ClientConfig | string;
+            ssl?: boolean;
+            username?: string;
+            password?: string;
+            channelOptions?: ChannelOptions;
+        };
+        collection?: string;
+        idKey?: string;
+        contentKey?: string;
+        metadataKey?: string;
+        embeddingKey?: string;
+    });
+    client(): MilvusClient;
+    private createCollection;
+    private ensureCollection;
+    add(nodes: BaseNode<Metadata>[]): Promise<string[]>;
+    delete(refDocId: string, deleteOptions?: Omit<DeleteReq, "ids">): Promise<void>;
+    toMilvusFilter(filters?: MetadataFilters): string | undefined;
+    query(query: VectorStoreQuery, _options?: object): Promise<VectorStoreQueryResult>;
+    persist(): Promise<void>;
+}
+
+export { MilvusVectorStore };

package/dist/index.edge-light.d.ts

@@ -0,0 +1,42 @@
+import { ChannelOptions } from '@grpc/grpc-js';
+import { BaseVectorStore, VectorStoreBaseParams, BaseNode, Metadata, MetadataFilters, VectorStoreQuery, VectorStoreQueryResult } from '@vectorstores/core';
+import { MilvusClient, ClientConfig, DeleteReq } from '@zilliz/milvus2-sdk-node';
+
+declare class MilvusVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    isEmbeddingQuery?: boolean;
+    private flatMetadata;
+    private milvusClient;
+    private collectionInitialized;
+    private collectionName;
+    private idKey;
+    private contentKey;
+    private metadataKey;
+    private embeddingKey;
+    constructor(init?: Partial<{
+        milvusClient: MilvusClient;
+    }> & VectorStoreBaseParams & {
+        params?: {
+            configOrAddress: ClientConfig | string;
+            ssl?: boolean;
+            username?: string;
+            password?: string;
+            channelOptions?: ChannelOptions;
+        };
+        collection?: string;
+        idKey?: string;
+        contentKey?: string;
+        metadataKey?: string;
+        embeddingKey?: string;
+    });
+    client(): MilvusClient;
+    private createCollection;
+    private ensureCollection;
+    add(nodes: BaseNode<Metadata>[]): Promise<string[]>;
+    delete(refDocId: string, deleteOptions?: Omit<DeleteReq, "ids">): Promise<void>;
+    toMilvusFilter(filters?: MetadataFilters): string | undefined;
+    query(query: VectorStoreQuery, _options?: object): Promise<VectorStoreQueryResult>;
+    persist(): Promise<void>;
+}
+
+export { MilvusVectorStore };

package/dist/index.edge-light.js

@@ -0,0 +1,182 @@
+import { BaseVectorStore, nodeToMetadata, MetadataMode, metadataDictToNode, parsePrimitiveValue, parseArrayValue } from '@vectorstores/core';
+import { getEnv } from '@vectorstores/env';
+import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';
+
+function parseScalarFilters(scalarFilters) {
+    const condition = scalarFilters.condition ?? "and";
+    const filters = [];
+    for (const filter of scalarFilters.filters){
+        switch(filter.operator){
+            case "==":
+            case "!=":
+                {
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} "${parsePrimitiveValue(filter.value)}"`);
+                    break;
+                }
+            case "in":
+                {
+                    const filterValue = parseArrayValue(filter.value).map((v)=>`"${v}"`).join(", ");
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} [${filterValue}]`);
+                    break;
+                }
+            case "nin":
+                {
+                    // Milvus does not support `nin` operator, so we need to manually check every value
+                    // Expected: not metadata["key"] != "value1" and not metadata["key"] != "value2"
+                    const filterStr = parseArrayValue(filter.value).map((v)=>`metadata["${filter.key}"] != "${v}"`).join(" && ");
+                    filters.push(filterStr);
+                    break;
+                }
+            case "<":
+            case "<=":
+            case ">":
+            case ">=":
+                {
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} ${parsePrimitiveValue(filter.value)}`);
+                    break;
+                }
+            default:
+                throw new Error(`Operator ${filter.operator} is not supported.`);
+        }
+    }
+    return filters.join(` ${condition} `);
+}
+class MilvusVectorStore extends BaseVectorStore {
+    constructor(init){
+        super(init), this.storesText = true, this.isEmbeddingQuery = false, this.flatMetadata = true, this.collectionInitialized = false;
+        if (init?.milvusClient) {
+            this.milvusClient = init.milvusClient;
+        } else {
+            const configOrAddress = init?.params?.configOrAddress ?? getEnv("MILVUS_ADDRESS");
+            const ssl = init?.params?.ssl ?? getEnv("MILVUS_SSL") === "true";
+            const username = init?.params?.username ?? getEnv("MILVUS_USERNAME");
+            const password = init?.params?.password ?? getEnv("MILVUS_PASSWORD");
+            if (!configOrAddress) {
+                throw new Error("Must specify MILVUS_ADDRESS via env variable.");
+            }
+            this.milvusClient = new MilvusClient(configOrAddress, ssl, username, password, init?.params?.channelOptions);
+        }
+        this.collectionName = init?.collection ?? "llamacollection";
+        this.idKey = init?.idKey ?? "id";
+        this.contentKey = init?.contentKey ?? "content";
+        this.metadataKey = init?.metadataKey ?? "metadata";
+        this.embeddingKey = init?.embeddingKey ?? "embedding";
+    }
+    client() {
+        return this.milvusClient;
+    }
+    async createCollection() {
+        await this.milvusClient.createCollection({
+            collection_name: this.collectionName,
+            fields: [
+                {
+                    name: this.idKey,
+                    data_type: DataType.VarChar,
+                    is_primary_key: true,
+                    max_length: 200
+                },
+                {
+                    name: this.embeddingKey,
+                    data_type: DataType.FloatVector,
+                    dim: 1536
+                },
+                {
+                    name: this.contentKey,
+                    data_type: DataType.VarChar,
+                    max_length: 9000
+                },
+                {
+                    name: this.metadataKey,
+                    data_type: DataType.JSON
+                }
+            ]
+        });
+        await this.milvusClient.createIndex({
+            collection_name: this.collectionName,
+            field_name: this.embeddingKey
+        });
+    }
+    async ensureCollection() {
+        if (!this.collectionInitialized) {
+            await this.milvusClient.connectPromise;
+            // Check collection exists
+            const isCollectionExist = await this.milvusClient.hasCollection({
+                collection_name: this.collectionName
+            });
+            if (!isCollectionExist.value) {
+                await this.createCollection();
+            }
+            await this.milvusClient.loadCollectionSync({
+                collection_name: this.collectionName
+            });
+            this.collectionInitialized = true;
+        }
+    }
+    async add(nodes) {
+        await this.ensureCollection();
+        const result = await this.milvusClient.insert({
+            collection_name: this.collectionName,
+            data: nodes.map((node)=>{
+                const metadata = nodeToMetadata(node, true, this.contentKey, this.flatMetadata);
+                const entry = {
+                    [this.idKey]: node.id_,
+                    [this.embeddingKey]: node.getEmbedding(),
+                    [this.contentKey]: node.getContent(MetadataMode.NONE),
+                    [this.metadataKey]: metadata
+                };
+                return entry;
+            })
+        });
+        if (!result.IDs) {
+            return [];
+        }
+        if ("int_id" in result.IDs) {
+            return result.IDs.int_id.data.map((i)=>String(i));
+        }
+        return result.IDs.str_id.data.map((s)=>String(s));
+    }
+    async delete(refDocId, deleteOptions) {
+        await this.ensureCollection();
+        await this.milvusClient.delete({
+            ids: [
+                refDocId
+            ],
+            collection_name: this.collectionName,
+            ...deleteOptions
+        });
+    }
+    toMilvusFilter(filters) {
+        if (!filters) return undefined;
+        // TODO: Milvus also support standard filters, we can add it later
+        return parseScalarFilters(filters);
+    }
+    async query(query, _options) {
+        await this.ensureCollection();
+        const found = await this.milvusClient.search({
+            collection_name: this.collectionName,
+            limit: query.similarityTopK,
+            vector: query.queryEmbedding,
+            filter: this.toMilvusFilter(query.filters)
+        });
+        const nodes = [];
+        const similarities = [];
+        const ids = [];
+        found.results.forEach((result)=>{
+            const node = metadataDictToNode(result.metadata);
+            node.setContent(result.content);
+            nodes.push(node);
+            similarities.push(result.score);
+            ids.push(String(result.id));
+        });
+        return {
+            nodes,
+            similarities,
+            ids
+        };
+    }
+    async persist() {
+    // no need to do anything
+    }
+}
+
+export { MilvusVectorStore };

package/dist/index.js

@@ -0,0 +1,182 @@
+import { BaseVectorStore, nodeToMetadata, MetadataMode, metadataDictToNode, parsePrimitiveValue, parseArrayValue } from '@vectorstores/core';
+import { getEnv } from '@vectorstores/env';
+import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';
+
+function parseScalarFilters(scalarFilters) {
+    const condition = scalarFilters.condition ?? "and";
+    const filters = [];
+    for (const filter of scalarFilters.filters){
+        switch(filter.operator){
+            case "==":
+            case "!=":
+                {
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} "${parsePrimitiveValue(filter.value)}"`);
+                    break;
+                }
+            case "in":
+                {
+                    const filterValue = parseArrayValue(filter.value).map((v)=>`"${v}"`).join(", ");
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} [${filterValue}]`);
+                    break;
+                }
+            case "nin":
+                {
+                    // Milvus does not support `nin` operator, so we need to manually check every value
+                    // Expected: not metadata["key"] != "value1" and not metadata["key"] != "value2"
+                    const filterStr = parseArrayValue(filter.value).map((v)=>`metadata["${filter.key}"] != "${v}"`).join(" && ");
+                    filters.push(filterStr);
+                    break;
+                }
+            case "<":
+            case "<=":
+            case ">":
+            case ">=":
+                {
+                    filters.push(`metadata["${filter.key}"] ${filter.operator} ${parsePrimitiveValue(filter.value)}`);
+                    break;
+                }
+            default:
+                throw new Error(`Operator ${filter.operator} is not supported.`);
+        }
+    }
+    return filters.join(` ${condition} `);
+}
+class MilvusVectorStore extends BaseVectorStore {
+    constructor(init){
+        super(init), this.storesText = true, this.isEmbeddingQuery = false, this.flatMetadata = true, this.collectionInitialized = false;
+        if (init?.milvusClient) {
+            this.milvusClient = init.milvusClient;
+        } else {
+            const configOrAddress = init?.params?.configOrAddress ?? getEnv("MILVUS_ADDRESS");
+            const ssl = init?.params?.ssl ?? getEnv("MILVUS_SSL") === "true";
+            const username = init?.params?.username ?? getEnv("MILVUS_USERNAME");
+            const password = init?.params?.password ?? getEnv("MILVUS_PASSWORD");
+            if (!configOrAddress) {
+                throw new Error("Must specify MILVUS_ADDRESS via env variable.");
+            }
+            this.milvusClient = new MilvusClient(configOrAddress, ssl, username, password, init?.params?.channelOptions);
+        }
+        this.collectionName = init?.collection ?? "llamacollection";
+        this.idKey = init?.idKey ?? "id";
+        this.contentKey = init?.contentKey ?? "content";
+        this.metadataKey = init?.metadataKey ?? "metadata";
+        this.embeddingKey = init?.embeddingKey ?? "embedding";
+    }
+    client() {
+        return this.milvusClient;
+    }
+    async createCollection() {
+        await this.milvusClient.createCollection({
+            collection_name: this.collectionName,
+            fields: [
+                {
+                    name: this.idKey,
+                    data_type: DataType.VarChar,
+                    is_primary_key: true,
+                    max_length: 200
+                },
+                {
+                    name: this.embeddingKey,
+                    data_type: DataType.FloatVector,
+                    dim: 1536
+                },
+                {
+                    name: this.contentKey,
+                    data_type: DataType.VarChar,
+                    max_length: 9000
+                },
+                {
+                    name: this.metadataKey,
+                    data_type: DataType.JSON
+                }
+            ]
+        });
+        await this.milvusClient.createIndex({
+            collection_name: this.collectionName,
+            field_name: this.embeddingKey
+        });
+    }
+    async ensureCollection() {
+        if (!this.collectionInitialized) {
+            await this.milvusClient.connectPromise;
+            // Check collection exists
+            const isCollectionExist = await this.milvusClient.hasCollection({
+                collection_name: this.collectionName
+            });
+            if (!isCollectionExist.value) {
+                await this.createCollection();
+            }
+            await this.milvusClient.loadCollectionSync({
+                collection_name: this.collectionName
+            });
+            this.collectionInitialized = true;
+        }
+    }
+    async add(nodes) {
+        await this.ensureCollection();
+        const result = await this.milvusClient.insert({
+            collection_name: this.collectionName,
+            data: nodes.map((node)=>{
+                const metadata = nodeToMetadata(node, true, this.contentKey, this.flatMetadata);
+                const entry = {
+                    [this.idKey]: node.id_,
+                    [this.embeddingKey]: node.getEmbedding(),
+                    [this.contentKey]: node.getContent(MetadataMode.NONE),
+                    [this.metadataKey]: metadata
+                };
+                return entry;
+            })
+        });
+        if (!result.IDs) {
+            return [];
+        }
+        if ("int_id" in result.IDs) {
+            return result.IDs.int_id.data.map((i)=>String(i));
+        }
+        return result.IDs.str_id.data.map((s)=>String(s));
+    }
+    async delete(refDocId, deleteOptions) {
+        await this.ensureCollection();
+        await this.milvusClient.delete({
+            ids: [
+                refDocId
+            ],
+            collection_name: this.collectionName,
+            ...deleteOptions
+        });
+    }
+    toMilvusFilter(filters) {
+        if (!filters) return undefined;
+        // TODO: Milvus also support standard filters, we can add it later
+        return parseScalarFilters(filters);
+    }
+    async query(query, _options) {
+        await this.ensureCollection();
+        const found = await this.milvusClient.search({
+            collection_name: this.collectionName,
+            limit: query.similarityTopK,
+            vector: query.queryEmbedding,
+            filter: this.toMilvusFilter(query.filters)
+        });
+        const nodes = [];
+        const similarities = [];
+        const ids = [];
+        found.results.forEach((result)=>{
+            const node = metadataDictToNode(result.metadata);
+            node.setContent(result.content);
+            nodes.push(node);
+            similarities.push(result.score);
+            ids.push(String(result.id));
+        });
+        return {
+            nodes,
+            similarities,
+            ids
+        };
+    }
+    async persist() {
+    // no need to do anything
+    }
+}
+
+export { MilvusVectorStore };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@vectorstores/milvus",
+  "description": "Milvus Storage for vectorstores",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "edge-light": {
+        "types": "./dist/index.edge-light.d.ts",
+        "default": "./dist/index.edge-light.js"
+      },
+      "workerd": {
+        "types": "./dist/index.edge-light.d.ts",
+        "default": "./dist/index.edge-light.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/schiesser/vectorstores.git",
+    "directory": "packages/providers/storage/milvus"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.5",
+    "@vectorstores/core": "0.1.0",
+    "@vectorstores/env": "0.1.0"
+  },
+  "peerDependencies": {
+    "@vectorstores/core": "0.1.0",
+    "@vectorstores/env": "0.1.0"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.12.2",
+    "@zilliz/milvus2-sdk-node": "^2.4.6"
+  },
+  "scripts": {
+    "build": "bunchee",
+    "dev": "bunchee --watch",
+    "test": "vitest run"
+  }
+}