@vectorstores/azure 0.1.0

package/dist/index.js

@@ -0,0 +1,1636 @@
+import { Document, metadataDictToNode, BaseVectorStore, MetadataMode, nodeToMetadata, FilterOperator, FilterCondition, VectorStoreQueryMode } from '@vectorstores/core';
+export * from './storage.js';
+import { KnownVectorSearchAlgorithmKind, KnownAnalyzerNames, KnownSearchFieldDataType, KnownVectorSearchAlgorithmMetric, KnownVectorSearchCompressionKind, SearchClient, SearchIndexClient, AzureKeyCredential, IndexDocumentsBatch } from '@azure/search-documents';
+import { DefaultAzureCredential, ManagedIdentityCredential } from '@azure/identity';
+import { consoleLogger, getEnv } from '@vectorstores/env';
+import { MongoClient } from 'mongodb';
+import { VectorEmbeddingDistanceFunction, VectorEmbeddingDataType, VectorIndexType, CosmosClient } from '@azure/cosmos';
+
+/**
+ * Read data from CosmosDB.
+ */ class SimpleCosmosDBReader {
+    constructor(client){
+        this.client = client;
+    }
+    /**
+   * Loads data from a Cosmos DB container
+   * @returns {Promise<Document[]>}
+   */ async loadData(config) {
+        if (!config.databaseName || !config.containerName) {
+            throw new Error("databaseName and containerName are required");
+        }
+        const database = this.client.database(config.databaseName);
+        const container = database.container(config.containerName);
+        const query = config.query || "SELECT * FROM c";
+        const fields = config.fields || [
+            "text"
+        ];
+        const fieldSeparator = config.fieldSeparator || "";
+        const metadataFields = config.metadataFields;
+        try {
+            const res = await container.items.query(query).fetchAll();
+            const documents = [];
+            for (const item of res.resources){
+                const texts = fields.map((name)=>item[name]);
+                const flattenedTexts = texts.flat();
+                const text = flattenedTexts.join(fieldSeparator);
+                let metadata = {};
+                if (metadataFields) {
+                    metadata = Object.fromEntries(metadataFields.map((name)=>[
+                            name,
+                            item[name]
+                        ]));
+                }
+                documents.push(new Document({
+                    id_: item.id,
+                    text,
+                    metadata
+                }));
+            }
+            return documents;
+        } catch (error) {
+            throw new Error(`Error loading data from Cosmos DB: ${error}`);
+        }
+    }
+}
+
+const AzureAISearchVectorStoreConfig = {
+    ALGORITHM_HNSW_NAME: "myHnsw",
+    ALGORITHM_EXHAUSTIVE_KNN_NAME: "myExhaustiveKnn",
+    PROFILE_HNSW_NAME: "myHnswProfile",
+    PROFILE_EXHAUSTIVE_KNN_NAME: "myExhaustiveKnnProfile",
+    COMPRESSION_TYPE_SCALAR: "myScalarCompression",
+    COMPRESSION_TYPE_BINARY: "myBinaryCompression",
+    SEMANTIC_CONFIG_NAME: "mySemanticConfig",
+    // 700 is default the maximum number of documents that can be sent in a single request
+    DEFAULT_MAX_BATCH_SIZE: 700,
+    // 14MB in bytes
+    DEFAULT_MAX_MB_SIZE: 14 * 1024 * 1024,
+    DEFAULT_USER_AGENT_PREFIX: "vectorstores-ts",
+    DEFAULT_AZURE_API_VERSION: "2024-09-01-preview"
+};
+
+class AzureQueryResultSearchBase {
+    constructor(query, fieldMapping, odataFilter, searchClient){
+        this._query = query;
+        this.fieldMapping = fieldMapping;
+        this.odataFilter = odataFilter;
+        this.searchClient = searchClient;
+    }
+    get selectFields() {
+        return [
+            this.fieldMapping["id"],
+            this.fieldMapping["chunk"],
+            this.fieldMapping["metadata"],
+            this.fieldMapping["doc_id"]
+        ];
+    }
+    createSearchQuery() {
+        return "*";
+    }
+    createQueryVector() {
+        return null;
+    }
+    async _createQueryResult(searchQuery, vectorQueries) {
+        if (!vectorQueries) {
+            vectorQueries = [];
+        }
+        if (!this.searchClient) {
+            throw new Error("SearchClient is not set");
+        }
+        const searchResults = await this.searchClient.search(searchQuery, {
+            top: this._query.similarityTopK,
+            select: this.selectFields,
+            filter: this.odataFilter || "",
+            vectorSearchOptions: {
+                queries: vectorQueries
+            }
+        });
+        const idResult = [];
+        const nodeResult = [];
+        const scoreResult = [];
+        for await (const result of searchResults.results){
+            const { document } = result;
+            // build node metadata from the metadata field in the document
+            const nodeId = document[this.fieldMapping["id"]];
+            const metadataStr = document[this.fieldMapping["metadata"]];
+            const metadata = typeof metadataStr === "string" ? JSON.parse(metadataStr) : {};
+            const score = result["score"];
+            const chunk = document[this.fieldMapping["chunk"]];
+            let node;
+            try {
+                node = metadataDictToNode(metadata);
+                node.setContent(chunk);
+                consoleLogger.log(`Retrieved node id ${nodeId}`);
+                idResult.push(nodeId);
+                nodeResult.push(node);
+                scoreResult.push(score);
+            } catch (err) {
+                consoleLogger.error(`Error while parsing metadata for node id ${nodeId}. Error: ${err}`);
+            }
+        }
+        consoleLogger.log(`Search query '${searchQuery}' returned ${idResult.length} results.`);
+        return {
+            nodes: nodeResult,
+            similarities: scoreResult,
+            ids: idResult
+        };
+    }
+    async search() {
+        const searchQuery = this.createSearchQuery();
+        const vectorQueries = this.createQueryVector();
+        return await this._createQueryResult(searchQuery, vectorQueries);
+    }
+}
+class AzureQueryResultSearchDefault extends AzureQueryResultSearchBase {
+    createQueryVector() {
+        if (!this._query.queryEmbedding) {
+            throw new Error("query.queryEmbedding is missing");
+        }
+        return [
+            {
+                kind: "vector",
+                vector: this._query.queryEmbedding,
+                kNearestNeighborsCount: this._query.similarityTopK,
+                fields: [
+                    this.fieldMapping["embedding"]
+                ]
+            }
+        ];
+    }
+}
+class AzureQueryResultSearchSparse extends AzureQueryResultSearchBase {
+    createSearchQuery() {
+        if (!this._query.queryStr) {
+            throw new Error("Query missing query string");
+        }
+        return this._query.queryStr;
+    }
+}
+class AzureQueryResultSearchHybrid extends AzureQueryResultSearchBase {
+    createQueryVector() {
+        return new AzureQueryResultSearchDefault(this._query, this.fieldMapping, this.odataFilter, this.searchClient).createQueryVector();
+    }
+    createSearchQuery() {
+        return new AzureQueryResultSearchSparse(this._query, this.fieldMapping, this.odataFilter, this.searchClient).createSearchQuery();
+    }
+}
+class AzureQueryResultSearchSemanticHybrid extends AzureQueryResultSearchHybrid {
+    createQueryVector() {
+        if (!this._query.queryEmbedding) {
+            throw new Error("query.queryEmbedding is missing");
+        }
+        return [
+            {
+                kind: "vector",
+                vector: this._query.queryEmbedding,
+                // kNearestNeighborsCount is set to 50 to align with the number of accept document in azure semantic reranking model.
+                // https://learn.microsoft.com/azure/search/semantic-search-overview
+                kNearestNeighborsCount: 50,
+                fields: [
+                    this.fieldMapping["embedding"]
+                ]
+            }
+        ];
+    }
+    async _createQueryResult(searchQuery, vectorQueries) {
+        if (!this.searchClient) {
+            throw new Error("SearchClient not set");
+        }
+        const searchResults = await this.searchClient.search(searchQuery, {
+            vectorSearchOptions: {
+                queries: vectorQueries
+            },
+            semanticSearchOptions: {
+                configurationName: AzureAISearchVectorStoreConfig.SEMANTIC_CONFIG_NAME
+            },
+            top: this._query.similarityTopK,
+            select: this.selectFields,
+            filter: this.odataFilter || "",
+            queryType: "semantic"
+        });
+        const idResult = [];
+        const nodeResult = [];
+        const scoreResult = [];
+        for await (const result of searchResults.results){
+            // build node metadata from the metadata field in the document
+            const { document } = result;
+            const nodeId = document[this.fieldMapping["id"]];
+            const metadataStr = document[this.fieldMapping["metadata"]];
+            const metadata = metadataStr ? JSON.parse(metadataStr) : {};
+            const chunk = document[this.fieldMapping["chunk"]];
+            const score = result["rerankerScore"];
+            let node;
+            try {
+                node = metadataDictToNode(metadata);
+                node.setContent(chunk);
+                idResult.push(nodeId);
+                nodeResult.push(node);
+                scoreResult.push(score);
+            } catch (err) {
+                consoleLogger.error(`Error while parsing metadata for node id ${nodeId}. Error: ${err}`);
+            }
+        }
+        return {
+            nodes: nodeResult,
+            similarities: scoreResult,
+            ids: idResult
+        };
+    }
+}
+
+/**
+ * Enumeration representing the supported index management operations
+ */ var IndexManagement = /*#__PURE__*/ function(IndexManagement) {
+    IndexManagement["NO_VALIDATION"] = "NoValidation";
+    IndexManagement["VALIDATE_INDEX"] = "ValidateIndex";
+    IndexManagement["CREATE_IF_NOT_EXISTS"] = "CreateIfNotExists";
+    return IndexManagement;
+}({});
+/**
+ * Enumeration representing the supported types for metadata fields in an
+ * Azure AI Search Index, corresponds with types supported in a flat
+ * metadata dictionary.
+ */ var MetadataIndexFieldType = /*#__PURE__*/ function(MetadataIndexFieldType) {
+    MetadataIndexFieldType["STRING"] = "Edm.String";
+    MetadataIndexFieldType["BOOLEAN"] = "Edm.Boolean";
+    MetadataIndexFieldType["INT32"] = "Edm.Int32";
+    MetadataIndexFieldType["INT64"] = "Edm.Int64";
+    MetadataIndexFieldType["DOUBLE"] = "Edm.Double";
+    MetadataIndexFieldType["COLLECTION"] = "Collection(Edm.String)";
+    return MetadataIndexFieldType;
+}({});
+const createSearchRequest = (fieldMapping, filterStr, batchSize, offset)=>{
+    return {
+        filter: filterStr,
+        top: batchSize,
+        skip: offset,
+        select: Object.keys(fieldMapping)
+    };
+};
+/**
+ * Azure AI Search vector store.
+ *
+ * @example
+```typescript
+import { DefaultAzureCredential, getBearerTokenProvider} from "@azure/identity";
+import {KnownAnalyzerNames, KnownVectorSearchAlgorithmKind } from "@azure/search-documents";
+
+// 1- Setup Azure OpenAI
+const azureADTokenProvider = getBearerTokenProvider(
+  new DefaultAzureCredential(),
+  "https://cognitiveservices.azure.com/.default",
+);
+
+// IMPORTANT: You need to deploy your own embedding model as well as your own chat completion model
+// NOTE: You can use whatever embedding model and language model that is supported by vectorstores
+const azure = {
+  azureADTokenProvider,
+  deployment: process.env.AZURE_DEPLOYMENT_NAME,
+};
+Settings.llm = new OpenAI({ azure });
+Settings.embedModel = new OpenAIEmbedding({
+  model: process.env.EMBEDDING_MODEL,
+  azure: {
+    ...azure,
+    deployment: process.env.EMBEDDING_MODEL,
+  },
+});
+
+// ---------------------------------------------------------
+// 2- Setup Azure AI Search
+// Define env variables in .env file
+// AZURE_AI_SEARCH_ENDPOINT=
+// AZURE_AI_SEARCH_KEY=
+// AZURE_OPENAI_ENDPOINT=
+// EMBEDDING_MODEL=text-embedding-ada-002
+// AZURE_DEPLOYMENT_NAME=gpt-4
+// AZURE_API_VERSION=2024-09-01-preview
+
+// Define index name
+const indexName = "vectorstores-vector-store";
+
+// ---------------------------------------------------------
+// 3a- Create Index (if it does not exist)
+// id:	      Edm.String
+// chunk:	    Edm.String
+// embedding:	Collection(Edm.Single)
+// metadata:	Edm.String
+// doc_id:	  Edm.String
+// author:	  Edm.String
+// theme:	    Edm.String
+// director:	Edm.String
+
+// Define metadata fields with their respective configurations
+const metadataFields = {
+  author: "author",
+  theme: ["theme", MetadataIndexFieldType.STRING],
+  director: "director",
+};
+
+// Define index parameters and vector store configuration
+// Index validation:
+// - IndexManagement.VALIDATE_INDEX: will validate before creating emnbedding index and will throw a runtime error if the index does not exist
+// - IndexManagement.NO_VALIDATION: will try to access the index and will throw a runtime error if the index does not exist
+// - IndexManagement.CREATE_IF_NOT_EXISTS: will create the index if it does not exist
+
+const vectorStore = new AzureAISearchVectorStore({
+  filterableMetadataFieldKeys:
+    metadataFields as unknown as FilterableMetadataFieldKeysType,
+  indexName,
+  indexManagement: IndexManagement.CREATE_IF_NOT_EXISTS,
+  idFieldKey: "id",
+  chunkFieldKey: "chunk",
+  embeddingFieldKey: "embedding",
+  metadataStringFieldKey: "metadata",
+  docIdFieldKey: "doc_id",
+  embeddingDimensionality: 1536,
+  hiddenFieldKeys: ["embedding"],
+  languageAnalyzer: KnownAnalyzerNames.EnLucene,
+  // store vectors on disk
+  vectorAlgorithmType: KnownVectorSearchAlgorithmKind.ExhaustiveKnn,
+
+  // Optional: Set to "scalar" or "binary" if using HNSW
+  compressionType: KnownVectorSearchCompressionKind.BinaryQuantization,
+});
+
+// ---------------------------------------------------------
+// 3a- Loading documents
+// Load the documents stored in the data/paul_graham/ using the SimpleDirectoryReader
+// NOTE: You can use whatever reader that is supported by vectorstores
+
+// Load documents using a directory reader
+const documents = await new SimpleDirectoryReader().loadData(
+  "data/paul_graham/",
+);
+const storageContext = await storageContextFromDefaults({ vectorStore });
+
+// Create index from documents with the specified storage context
+const index = await VectorStoreIndex.fromDocuments(documents, {
+  storageContext,
+  docStoreStrategy: DocStoreStrategy.UPSERTS,
+});
+
+const queryEngine = index.asQueryEngine();
+const response = await queryEngine.query({
+  query: "What did the author do growing up?",
+  similarityTopK: 3,
+} as any);
+console.log({ response });
+ */ class AzureAISearchVectorStore extends BaseVectorStore {
+    #languageAnalyzer;
+    #embeddingDimensionality;
+    #vectorProfileName;
+    #compressionType;
+    #indexManagement;
+    #indexName;
+    #fieldMapping;
+    #metadataToIndexFieldMap;
+    #idFieldKey;
+    #chunkFieldKey;
+    #embeddingFieldKey;
+    #docIdFieldKey;
+    #metadataStringFieldKey;
+    #serviceApiVersion;
+    #indexMapping;
+    #hiddenFiledKeys;
+    constructor(options){
+        super(options), this.storesText = true, this.#metadataToIndexFieldMap = new Map(), this.flatMetadata = true;
+        // set default values
+        options.vectorAlgorithmType ||= KnownVectorSearchAlgorithmKind.ExhaustiveKnn;
+        options.languageAnalyzer ||= KnownAnalyzerNames.EnLucene;
+        options.indexManagement ||= "NoValidation";
+        options.embeddingDimensionality ||= 1536;
+        options.serviceApiVersion ||= getEnv("AZURE_SEARCH_API_VERSION");
+        options.hiddenFieldKeys ||= [];
+        // set props
+        this.#serviceApiVersion = options.serviceApiVersion || AzureAISearchVectorStoreConfig.DEFAULT_AZURE_API_VERSION;
+        this.#languageAnalyzer = options.languageAnalyzer;
+        this.#compressionType = options.compressionType;
+        this.#embeddingDimensionality = options.embeddingDimensionality;
+        this.#indexManagement = options.indexManagement;
+        this.#indexName = options.indexName;
+        this.#idFieldKey = options.idFieldKey;
+        this.#docIdFieldKey = options.docIdFieldKey;
+        this.#chunkFieldKey = options.chunkFieldKey;
+        this.#embeddingFieldKey = options.embeddingFieldKey;
+        this.#metadataStringFieldKey = options.metadataStringFieldKey;
+        this.#hiddenFiledKeys = options.hiddenFieldKeys;
+        this.#indexMapping = options.indexMapping || this.#defaultIndexMapping;
+        // Default field mapping
+        this.#fieldMapping = {
+            ["id"]: options.idFieldKey,
+            ["doc_id"]: options.docIdFieldKey,
+            ["chunk"]: options.chunkFieldKey,
+            ["embedding"]: options.embeddingFieldKey,
+            ["metadata"]: options.metadataStringFieldKey
+        };
+        this.#setVectorProfileName(options.vectorAlgorithmType);
+        this.#valideSearchOrIndexClient(options);
+        // Normalizing metadata to index fields
+        this.#metadataToIndexFieldMap = this.#normalizeMetadataToIndexFields(options.filterableMetadataFieldKeys);
+    }
+    // private
+    #normalizeMetadataToIndexFields(filterableMetadataFieldKeys) {
+        const indexFieldSpec = new Map();
+        if (Array.isArray(filterableMetadataFieldKeys)) {
+            // if filterableMetadataFieldKeys is an array, use the field name as the index field name
+            // eg. [
+            //  "author",
+            //  "theme",
+            //  "director"
+            // ] => {
+            //  "author": ["author", "Edm.String"],
+            //  "theme": ["theme", "Edm.String"],
+            //  "director": ["director", "Edm.String"]
+            // }
+            filterableMetadataFieldKeys.forEach((field)=>{
+                indexFieldSpec.set(field, [
+                    field,
+                    "Edm.String"
+                ]);
+            });
+        } else if (typeof filterableMetadataFieldKeys === "object") {
+            // if filterableMetadataFieldKeys is an object, use the key as the index field name
+            // and the value as the metadata field name
+            // eg. {
+            //  "author": "author",
+            //  "theme": ["topic", MetadataIndexFieldType.STRING],
+            //  "director": "director"
+            // } => {
+            //  "author": ["author", "Edm.String"],
+            //  "theme": ["topic", "Edm.String"],
+            //  "director": ["director", "Edm.String"]
+            // }
+            // we also support specifying the metadata field type
+            // MetadataIndexFieldType.INT32 --> "Edm.Int32"
+            // MetadataIndexFieldType.INT64 --> "Edm.Int64"
+            // MetadataIndexFieldType.DOUBLE --> "Edm.Double"
+            // MetadataIndexFieldType.BOOLEAN --> "Edm.Boolean"
+            // MetadataIndexFieldType.COLLECTION --> "Collection(Edm.String)"
+            Object.entries(filterableMetadataFieldKeys).forEach(([k, v])=>{
+                if (Array.isArray(v)) {
+                    indexFieldSpec.set(k, [
+                        v[0],
+                        v[1]
+                    ]);
+                } else {
+                    switch(v){
+                        case "Edm.String":
+                            indexFieldSpec.set(k, [
+                                v,
+                                "Edm.String"
+                            ]);
+                            break;
+                        case "Edm.Int32":
+                            indexFieldSpec.set(k, [
+                                v,
+                                "Edm.Int32"
+                            ]);
+                            break;
+                        case "Edm.Int64":
+                            indexFieldSpec.set(k, [
+                                v,
+                                "Edm.Int64"
+                            ]);
+                            break;
+                        case "Edm.Double":
+                            indexFieldSpec.set(k, [
+                                v,
+                                "Edm.Double"
+                            ]);
+                            break;
+                        case "Edm.Boolean":
+                            indexFieldSpec.set(k, [
+                                v,
+                                "Edm.Boolean"
+                            ]);
+                            break;
+                        case "Collection(Edm.String)":
+                            indexFieldSpec.set(k, [
+                                v,
+                                "Collection(Edm.String)"
+                            ]);
+                            break;
+                        default:
+                            // Index field name and metadata field name may differ
+                            // Use String as the default index field type
+                            indexFieldSpec.set(k, [
+                                v,
+                                "Edm.String"
+                            ]);
+                            break;
+                    }
+                }
+            });
+        }
+        return indexFieldSpec;
+    }
+    #defaultIndexMapping(node, metadata) {
+        // include metadata fields in the index document
+        const filterableMetadata = {};
+        for (const [fieldName, _fieldType] of this.#metadataToIndexFieldMap.values()){
+            filterableMetadata[fieldName] = metadata[fieldName];
+        }
+        return {
+            [this.#embeddingFieldKey]: node.getEmbedding(),
+            [this.#idFieldKey]: node.id_,
+            [this.#docIdFieldKey]: node.id_,
+            [this.#chunkFieldKey]: node.getContent(MetadataMode.NONE),
+            [this.#metadataStringFieldKey]: JSON.stringify(metadata),
+            ...filterableMetadata
+        };
+    }
+    #setVectorProfileName(vectorAlgorithmType) {
+        if (vectorAlgorithmType === KnownVectorSearchAlgorithmKind.ExhaustiveKnn) {
+            this.#vectorProfileName = "myExhaustiveKnnProfile";
+        } else if (vectorAlgorithmType === KnownVectorSearchAlgorithmKind.Hnsw) {
+            this.#vectorProfileName = "myHnswProfile";
+        } else {
+            throw new Error("Only 'exhaustiveKnn' and 'hnsw' are supported for vectorAlgorithmType");
+        }
+    }
+    /**
+   * Create a list of index fields for storing metadata values.
+   * @returns List of index fields for storing metadata values
+   */ #createMetadataIndexFields() {
+        const indexFields = [];
+        for (const [fieldName, fieldType] of this.#metadataToIndexFieldMap.values()){
+            if (this.#fieldMapping[fieldName]) {
+                consoleLogger.log(`Skipping metadata field ${fieldName} as it is already mapped to an index field`);
+                continue;
+            }
+            let indexFieldType;
+            switch(fieldType){
+                case "Edm.String":
+                    indexFieldType = KnownSearchFieldDataType.String;
+                    break;
+                case "Edm.Int32":
+                    indexFieldType = KnownSearchFieldDataType.Int32;
+                    break;
+                case "Edm.Int64":
+                    indexFieldType = KnownSearchFieldDataType.Int64;
+                    break;
+                case "Edm.Double":
+                    indexFieldType = KnownSearchFieldDataType.Double;
+                    break;
+                case "Edm.Boolean":
+                    indexFieldType = KnownSearchFieldDataType.Boolean;
+                    break;
+                case "Collection(Edm.String)":
+                    indexFieldType = `Collection(${KnownSearchFieldDataType.String})`;
+                    break;
+                default:
+                    throw new Error(`Unsupported field type: ${fieldType}`);
+            }
+            indexFields.push({
+                name: fieldName,
+                type: indexFieldType,
+                filterable: true
+            });
+        }
+        return indexFields;
+    }
+    // index management
+    async #indexExists(indexName) {
+        if (!indexName) {
+            throw new Error(`options.indexName is not valid`);
+        }
+        const availableIndexNames = await this._indexClient?.listIndexesNames();
+        if (!availableIndexNames) {
+            return false;
+        }
+        let listOfIndexNames = await availableIndexNames.next();
+        const indexNames = [];
+        while(!listOfIndexNames.done){
+            indexNames.push(listOfIndexNames.value);
+            listOfIndexNames = await availableIndexNames.next();
+        }
+        return indexNames.includes(indexName);
+    }
+    async #createIndexIfNotExists(indexName) {
+        const indexExists = await this.#indexExists(indexName);
+        if (!indexExists) {
+            consoleLogger.log(`Index ${indexName} does not exist in Azure AI Search, creating index`);
+            await this.#createIndex(indexName);
+        }
+    }
+    /**
+   * Creates a default index based on the supplied index name, key field names and
+   * metadata filtering keys.
+   * @param indexName The name of the index to create
+   */ async #createIndex(indexName) {
+        consoleLogger.log(`Configuring ${indexName} fields for Azure AI Search`);
+        const fields = [
+            {
+                name: this.#fieldMapping["id"],
+                type: KnownSearchFieldDataType.String,
+                hidden: this.#hiddenFiledKeys?.includes(this.#fieldMapping["id"]),
+                key: true,
+                filterable: true,
+                retrievable: true,
+                searchable: true
+            },
+            {
+                name: this.#fieldMapping["chunk"],
+                type: KnownSearchFieldDataType.String,
+                hidden: this.#hiddenFiledKeys?.includes(this.#fieldMapping["chunk"]),
+                analyzerName: this.#languageAnalyzer,
+                searchable: true
+            },
+            {
+                name: this.#fieldMapping["embedding"],
+                type: `Collection(${KnownSearchFieldDataType.Single})`,
+                vectorSearchDimensions: this.#embeddingDimensionality,
+                vectorSearchProfileName: this.#vectorProfileName,
+                hidden: this.#hiddenFiledKeys?.includes(this.#fieldMapping["embedding"]),
+                searchable: true
+            },
+            {
+                name: this.#fieldMapping["metadata"],
+                hidden: this.#hiddenFiledKeys?.includes(this.#fieldMapping["metadata"]),
+                type: KnownSearchFieldDataType.String
+            },
+            {
+                name: this.#fieldMapping["doc_id"],
+                type: KnownSearchFieldDataType.String,
+                hidden: this.#hiddenFiledKeys?.includes(this.#fieldMapping["doc_id"]),
+                filterable: true,
+                retrievable: true,
+                searchable: true
+            }
+        ];
+        consoleLogger.log(`Configuring ${indexName} metadata fields`);
+        const metadataIndexFields = this.#createMetadataIndexFields();
+        fields.push(...metadataIndexFields);
+        consoleLogger.log(`Configuring ${indexName} vector search`);
+        const compressions = this.#getCompressions();
+        consoleLogger.log(`Configuring ${indexName} vector search with ${this.#compressionType} compression`);
+        const vectorSearch = {
+            algorithms: [
+                {
+                    name: AzureAISearchVectorStoreConfig.ALGORITHM_HNSW_NAME,
+                    kind: KnownVectorSearchAlgorithmKind.Hnsw,
+                    parameters: {
+                        m: 4,
+                        efConstruction: 400,
+                        efSearch: 500,
+                        metric: KnownVectorSearchAlgorithmMetric.Cosine
+                    }
+                },
+                {
+                    name: AzureAISearchVectorStoreConfig.ALGORITHM_EXHAUSTIVE_KNN_NAME,
+                    kind: KnownVectorSearchAlgorithmKind.ExhaustiveKnn,
+                    parameters: {
+                        metric: KnownVectorSearchAlgorithmMetric.Cosine
+                    }
+                }
+            ],
+            compressions,
+            profiles: [
+                {
+                    name: AzureAISearchVectorStoreConfig.PROFILE_HNSW_NAME,
+                    algorithmConfigurationName: AzureAISearchVectorStoreConfig.ALGORITHM_HNSW_NAME,
+                    compressionName: compressions?.[0]?.compressionName
+                },
+                {
+                    name: AzureAISearchVectorStoreConfig.PROFILE_EXHAUSTIVE_KNN_NAME,
+                    algorithmConfigurationName: AzureAISearchVectorStoreConfig.ALGORITHM_EXHAUSTIVE_KNN_NAME
+                }
+            ]
+        };
+        consoleLogger.log(`Configuring ${indexName} semantic search`);
+        const semanticConfig = {
+            name: AzureAISearchVectorStoreConfig.SEMANTIC_CONFIG_NAME,
+            prioritizedFields: {
+                contentFields: [
+                    {
+                        name: this.#fieldMapping["chunk"]
+                    }
+                ],
+                keywordsFields: [
+                    {
+                        name: this.#fieldMapping["metadata"]
+                    }
+                ],
+                titleField: {
+                    name: this.#fieldMapping["id"]
+                }
+            }
+        };
+        const semanticSearch = {
+            configurations: [
+                semanticConfig
+            ]
+        };
+        const index = {
+            name: indexName,
+            fields: fields,
+            vectorSearch: vectorSearch,
+            semanticSearch: semanticSearch
+        };
+        consoleLogger.log(`Creating ${indexName} search index with configuration:`);
+        consoleLogger.log({
+            index
+        });
+        await this._indexClient?.createIndex(index);
+    }
+    /**
+   * Get the compressions for the vector search
+   * @returns Array of compressions. See {@link VectorSearchCompression}
+   */ #getCompressions() {
+        const compressions = [];
+        if (this.#compressionType === KnownVectorSearchCompressionKind.BinaryQuantization) {
+            compressions.push({
+                compressionName: AzureAISearchVectorStoreConfig.COMPRESSION_TYPE_BINARY,
+                kind: KnownVectorSearchCompressionKind.BinaryQuantization
+            });
+        } else if (this.#compressionType === KnownVectorSearchCompressionKind.ScalarQuantization) {
+            compressions.push({
+                compressionName: AzureAISearchVectorStoreConfig.COMPRESSION_TYPE_SCALAR,
+                kind: KnownVectorSearchCompressionKind.ScalarQuantization
+            });
+        }
+        return compressions;
+    }
+    #valideSearchOrIndexClient(options) {
+        if (options.searchClient) {
+            if (options.searchClient instanceof SearchClient) {
+                consoleLogger.log("Using provided Azure SearchClient");
+                this._searchClient = options.searchClient;
+                if (options.indexName) {
+                    throw new Error("options.indexName cannot be supplied if using options.searchClient");
+                }
+            } else {
+                throw new Error("options.searchClient must be an instance of SearchClient");
+            }
+        } else {
+            this.createSearchClient(options);
+        }
+        if (options.indexClient) {
+            if (options.indexClient instanceof SearchIndexClient) {
+                if (!options.indexName) {
+                    throw new Error("options.indexName must be supplied if using options.indexClient");
+                }
+                this._indexClient = options.indexClient;
+            } else {
+                throw new Error("options.indexClient must be an instance of SearchIndexClient");
+            }
+        } else {
+            this.createSearchIndexClient(options);
+        }
+        if (options.indexManagement === "CreateIfNotExists" && !this._indexClient) {
+            throw new Error("IndexManagement.CREATE_IF_NOT_EXISTS requires options.indexClient");
+        }
+        if (!this._searchClient && !this._indexClient) {
+            throw new Error("Either options.searchClient or options.indexClient must be supplied");
+        }
+    }
+    #buildCredentials(options) {
+        let { credential: credential, key, endpoint, indexName } = options;
+        // validate and use credential
+        if (credential) {
+            // if credential are provided, ensure they are an instance of valid credential instances
+            if (!(credential instanceof AzureKeyCredential || credential instanceof DefaultAzureCredential || credential instanceof ManagedIdentityCredential)) {
+                throw new Error("options.credential must be an instance of AzureKeyCredential or DefaultAzureCredential or ManagedIdentityCredential");
+            }
+        } else {
+            key ??= getEnv("AZURE_AI_SEARCH_KEY");
+            if (key) {
+                consoleLogger.log("Using provided Azure Search key");
+                credential = new AzureKeyCredential(key);
+            } else {
+                const clientId = getEnv("AZURE_CLIENT_ID");
+                if (clientId) {
+                    consoleLogger.log("Using Azure Managed identity");
+                    credential = new ManagedIdentityCredential(clientId);
+                } else {
+                    // if key wasn't provided, try using DefaultAzureCredential
+                    consoleLogger.log("Using Default Azure Credential");
+                    credential = new DefaultAzureCredential();
+                }
+            }
+        }
+        // validate and use endpoint
+        endpoint ??= getEnv("AZURE_AI_SEARCH_ENDPOINT");
+        if (!endpoint) {
+            throw new Error("options.endpoint must be provided or set as an environment variable: AZURE_AI_SEARCH_ENDPOINT");
+        } else {
+            // check if enpoint is a valid URL
+            try {
+                new URL(endpoint);
+            } catch (error) {
+                throw new Error(`options.endpoint must be a valid URL.`);
+            }
+        }
+        // validate and use indexName
+        if (!indexName) {
+            if (this._searchClient) {
+                indexName = this._searchClient.indexName;
+            } else {
+                throw new Error("options.indexName must be provided");
+            }
+        }
+        return {
+            credential,
+            endpoint,
+            indexName
+        };
+    }
+    createSearchIndexClient(options) {
+        const { credential, endpoint } = this.#buildCredentials(options);
+        this._indexClient = new SearchIndexClient(endpoint, credential, {
+            serviceVersion: this.#serviceApiVersion,
+            userAgentOptions: {
+                userAgentPrefix: options.userAgent ?? AzureAISearchVectorStoreConfig.DEFAULT_USER_AGENT_PREFIX
+            }
+        });
+    }
+    createSearchClient(options) {
+        const { credential, endpoint, indexName } = this.#buildCredentials(options);
+        this._searchClient = new SearchClient(endpoint, indexName, credential, {
+            serviceVersion: this.#serviceApiVersion,
+            userAgentOptions: {
+                userAgentPrefix: options.userAgent ?? AzureAISearchVectorStoreConfig.DEFAULT_USER_AGENT_PREFIX
+            }
+        });
+    }
+    async #validateIndex(indexName) {
+        if (this._indexClient && indexName && !await this.#indexExists(indexName)) {
+            throw new Error(`Validation failed, index ${indexName} does not exist.`);
+        }
+    }
+    /**
+   * Create AI Search index document from embedding result.
+   * @param node The node to create the index document from
+   * @returns The mapped index document from the node
+   */ #createIndexDocument(node) {
+        consoleLogger.log(`Mapping indexed document: ${node.id_}`);
+        const metadata = nodeToMetadata(node, true, this.#chunkFieldKey, this.flatMetadata);
+        return this.#indexMapping(node, metadata);
+    }
+    /**
+   * Generate an OData filter string using supplied metadata filters.
+   * @param metadataFilters
+   * @returns
+   */ #createOdataFilter(metadataFilters) {
+        const odataFilter = [];
+        for (const subfilter of metadataFilters.filters){
+            // Join values with ' or ' to create an OR condition inside the any function
+            const metadataMapping = this.#metadataToIndexFieldMap.get(subfilter.key);
+            if (!metadataMapping) {
+                throw new Error(`Metadata field '${subfilter.key}' is missing a mapping to an index field. Please provide an entry in 'filterableMetadataFieldKeys' for this vector store.`);
+            }
+            const indexField = metadataMapping[0];
+            if (subfilter.operator === FilterOperator.IN) {
+                let valueStr;
+                if (Array.isArray(subfilter.value)) {
+                    valueStr = subfilter.value.map((value)=>typeof value === "string" ? `t eq '${value}'` : `t eq ${value}`).join(" or ");
+                } else {
+                    valueStr = typeof subfilter.value === "string" ? `t eq '${subfilter.value}'` : `t eq ${subfilter.value}`;
+                }
+                odataFilter.push(`${indexField}/any(t: ${valueStr})`);
+            } else if (subfilter.operator === FilterOperator.EQ) {
+                const escapedValue = typeof subfilter.value === "string" ? subfilter.value.replace(/'/g, "''") : subfilter.value;
+                odataFilter.push(`${indexField} eq '${escapedValue}'`);
+            } else {
+                throw new Error(`Unsupported filter operator ${subfilter.operator}. Supported operators are 'IN' and 'EQ'`);
+            }
+        }
+        let odataExpr = "";
+        if (metadataFilters.condition === FilterCondition.AND) {
+            odataExpr = odataFilter.join(" and ");
+        } else if (metadataFilters.condition === FilterCondition.OR) {
+            odataExpr = odataFilter.join(" or ");
+        } else {
+            throw new Error(`Unsupported filter condition ${metadataFilters.condition}. Supported conditions are 'AND' and 'OR'`);
+        }
+        consoleLogger.log(`OData filter: ${odataExpr}`);
+        return odataExpr;
+    }
+    #createNodeFromResult(result, fieldMapping) {
+        const { document } = result;
+        const metadataStr = document[fieldMapping["metadata"]];
+        const metadata = metadataStr ? JSON.parse(metadataStr) : {};
+        try {
+            const node = metadataDictToNode(metadata);
+            node.setContent(document[fieldMapping["chunk"]]);
+            node.embedding = document[fieldMapping["embedding"]];
+            return node;
+        } catch (error) {
+            throw new Error(`Failed to create node from search result`);
+        }
+    }
+    #buildFilterString(fieldMapping, nodeIds, filters) {
+        let filterStr = "";
+        if (nodeIds && nodeIds.length > 0) {
+            filterStr = nodeIds.map((nodeId)=>`${fieldMapping["id"]} eq '${nodeId}'`).join(" or ");
+        }
+        if (filters) {
+            const metadataFilter = this.#createOdataFilter(filters);
+            if (filterStr) {
+                filterStr = `(${filterStr}) or (${metadataFilter})`;
+            } else {
+                filterStr = metadataFilter;
+            }
+        }
+        return filterStr;
+    }
+    #processBatchResults(batchNodes, nodes, batchSize, limit) {
+        if (batchNodes.length === 0) {
+            return [
+                nodes,
+                false
+            ];
+        }
+        nodes = [
+            ...nodes,
+            ...batchNodes
+        ];
+        // If we've hit the requested limit, stop
+        if (limit && nodes.length >= limit) {
+            return [
+                nodes.slice(0, limit),
+                false
+            ];
+        }
+        // If we got fewer results than batch size, we've hit the end
+        if (batchNodes.length < batchSize) {
+            return [
+                nodes,
+                false
+            ];
+        }
+        return [
+            nodes,
+            true
+        ];
+    }
+    // public
+    /**
+   * Get search client
+   * @returns Azure AI Search client. See {@link SearchClient}
+   */ client() {
+        return this._searchClient;
+    }
+    /**
+   * Get index client
+   * @returns Azure AI Search index client. See {@link SearchIndexClient}
+   */ indexClient() {
+        return this._indexClient;
+    }
+    /**
+   * Add nodes to index associated with the configured search client.
+   * @param nodes List of nodes with embeddings to add to the index
+   * @returns List of node IDs that were added to the index
+   */ async add(nodes) {
+        if (!this._searchClient) {
+            throw new Error("Async Search client not initialized");
+        }
+        if (!nodes || nodes.length === 0) {
+            return [];
+        }
+        if (nodes.length > 0) {
+            if (this.#indexManagement === "CreateIfNotExists" && this.#indexName) {
+                await this.#createIndexIfNotExists(this.#indexName);
+            }
+            if (this.#indexManagement === "ValidateIndex") {
+                await this.#validateIndex(this.#indexName);
+            }
+        }
+        const accumulator = new IndexDocumentsBatch();
+        let documents = [];
+        const ids = [];
+        let accumulatedSize = 0;
+        const maxSize = AzureAISearchVectorStoreConfig.DEFAULT_MAX_MB_SIZE;
+        const maxDocs = AzureAISearchVectorStoreConfig.DEFAULT_MAX_BATCH_SIZE;
+        for (const node of nodes){
+            consoleLogger.log(`Processing embedding: ${node.id_}`);
+            const indexDocument = this.#createIndexDocument(node);
+            const documentSize = JSON.stringify(indexDocument).length; // in bytes
+            documents.push(indexDocument);
+            accumulatedSize += documentSize;
+            accumulator.upload(documents);
+            if (documents.length >= maxDocs || accumulatedSize >= maxSize) {
+                consoleLogger.log(`Uploading batch of size ${documents.length}, current progress ${ids.length} of ${nodes.length}, accumulated size ${(accumulatedSize / (1024 * 1024)).toFixed(2)} MB`);
+                await this._searchClient.indexDocuments(accumulator);
+                documents = [];
+                accumulatedSize = 0;
+            }
+            ids.push(node.id_);
+        }
+        if (documents.length > 0) {
+            consoleLogger.log(`Uploading remaining batch of size ${documents.length}, current progress ${ids.length} of ${nodes.length}, accumulated size ${(accumulatedSize / (1024 * 1024)).toFixed(2)} MB`);
+            await this._searchClient.indexDocuments(accumulator);
+        }
+        return ids;
+    }
+    /**
+   * Delete documents from the AI Search Index with docIdFieldKey (doc_id) field equal to refDocId.
+   * @param refDocId The reference document ID to delete from the index
+   */ async delete(refDocId) {
+        // Check if index exists
+        if (!await this.#indexExists(this.#indexName)) {
+            return;
+        }
+        if (!this._searchClient) {
+            throw new Error("searchClient is not initialized");
+        }
+        // Define filter and batch size
+        const filterExpr = `${this.#fieldMapping["doc_id"]} eq '${refDocId}'`;
+        const batchSize = 1000;
+        while(true){
+            // Search for documents to delete
+            consoleLogger.log(`Searching with filter ${filterExpr}`);
+            const searchResults = await this._searchClient.search("*", {
+                filter: filterExpr,
+                top: batchSize
+            });
+            // Collect document IDs to delete
+            const docsToDelete = [];
+            for await (const result of searchResults.results){
+                const { document } = result;
+                docsToDelete.push(document);
+            }
+            // Delete documents if found
+            if (docsToDelete.length > 0) {
+                consoleLogger.log(`Deleting ${docsToDelete.length} documents`);
+                await this._searchClient.deleteDocuments(docsToDelete);
+            } else {
+                consoleLogger.log("No documents found to delete");
+                break;
+            }
+        }
+    }
+    /**
+   * Get nodes asynchronously from the Azure AI Search index.
+   * @param nodeIds List of node IDs to retrieve from the index
+   * @param filters Metadata filters to apply to the search
+   * @param limit Maximum number of nodes to retrieve
+   * @returns List of nodes retrieved from the index
+   */ async getNodes(nodeIds, filters, limit) {
+        if (!this._searchClient) {
+            throw new Error("SearchClient not initialized");
+        }
+        const filterStr = this.#buildFilterString(this.#fieldMapping, nodeIds, filters);
+        const nodes = [];
+        const batchSize = 1000; // Azure Search batch size limit
+        while(true){
+            try {
+                const searchRequest = createSearchRequest(this.#fieldMapping, filterStr, batchSize, nodes.length);
+                const results = await this._searchClient.search("*", searchRequest);
+                const batchNodes = [];
+                for await (const result of results.results){
+                    batchNodes.push(this.#createNodeFromResult(result, this.#fieldMapping));
+                }
+                const [updatedNodes, continueFetching] = this.#processBatchResults(batchNodes, nodes, batchSize, limit);
+                nodes.push(...updatedNodes);
+                if (!continueFetching) {
+                    break;
+                }
+            } catch (error) {
+                throw new Error(`Failed to get nodes from Azure AI Search: ${error}`);
+            }
+        }
+        return nodes;
+    }
+    async query(query) {
+        let odataFilter;
+        if (query.filters) {
+            odataFilter = this.#createOdataFilter(query.filters);
+            consoleLogger.log(`Querying with OData filter: ${odataFilter}`);
+        }
+        consoleLogger.log({
+            query
+        });
+        // Define base AzureQueryResultSearch object based on query mode
+        let azureQueryResultSearch = new AzureQueryResultSearchDefault(query, this.#fieldMapping, odataFilter, this._searchClient);
+        switch(query.mode){
+            case VectorStoreQueryMode.SPARSE:
+                azureQueryResultSearch = new AzureQueryResultSearchSparse(query, this.#fieldMapping, odataFilter, this._searchClient);
+                break;
+            case VectorStoreQueryMode.HYBRID:
+                azureQueryResultSearch = new AzureQueryResultSearchHybrid(query, this.#fieldMapping, odataFilter, this._searchClient);
+                break;
+            case VectorStoreQueryMode.SEMANTIC_HYBRID:
+                azureQueryResultSearch = new AzureQueryResultSearchSemanticHybrid(query, this.#fieldMapping, odataFilter, this._searchClient);
+                break;
+        }
+        // Execute the search and return the result
+        return await azureQueryResultSearch.search();
+    }
+}
+
+var version = "0.1.0";
+var pkg = {
+	version: version};
+
+/** Azure Cosmos DB for MongoDB vCore Similarity type. */ const AzureCosmosDBMongoDBSimilarityType = {
+    /** Cosine similarity */ COS: "COS",
+    /** Inner - product */ IP: "IP",
+    /** Euclidian distance */ L2: "L2"
+};
+/**
+ * Azure Cosmos DB for MongoDB vCore vector store.
+ * To use this, you should have both:
+ * - the `mongodb` NPM package installed
+ * - a connection string associated with a MongoDB VCore Cluster
+ *
+ * You do not need to create a database or collection, it will be created
+ * automatically.
+ *
+ * You also need an index on the collection, which is by default be created
+ * automatically using the `createIndex` method.
+ */ class AzureCosmosDBMongoDBVectorStore extends BaseVectorStore {
+    constructor(init){
+        super(init), this.storesText = true, this.flatMetadata = true;
+        if (init.mongodbClient) {
+            this.mongodbClient = init.mongodbClient;
+        } else {
+            const mongoUri = getEnv("AZURE_COSMOSDB_MONGODB_CONNECTION_STRING");
+            if (!mongoUri) {
+                throw new Error("AzureCosmosDBMongoDBVectorStore client or connection string must be set.");
+            }
+            this.mongodbClient = new MongoClient(mongoUri, {
+                appName: "VECTORSTORES_JS"
+            });
+        }
+        this.mongodbClient.appendMetadata({
+            name: "VECTORSTORES_AZURE_COSMOS_VCORE_VECTOR_STORE",
+            version: pkg.version
+        });
+        this.dbName = init.dbName ?? "documentsDB";
+        this.collectionName = init.collectionName ?? "documents";
+        this.indexedMetadataFields = init.indexedMetadataFields ?? [];
+        this.indexName = init.indexName ?? "vectorSearchIndex";
+        this.embeddingKey = init.embeddingKey ?? "vectorContent";
+        this.idKey = init.idKey ?? "id";
+        this.textKey = init.textKey ?? "text";
+        this.metadataKey = init.metadataKey ?? "metadata";
+        this.indexOptions = init.indexOptions ?? {};
+        this.database = this.mongodbClient.db(this.dbName);
+    }
+    client() {
+        return this.mongodbClient;
+    }
+    async ensureCollection() {
+        if (!this.collection) {
+            const collection = await this.mongodbClient.db(this.dbName).createCollection(this.collectionName);
+            this.collection = collection;
+        }
+        return this.collection;
+    }
+    async add(nodes) {
+        if (!nodes || nodes.length === 0) {
+            return [];
+        }
+        const dataToInsert = nodes.map((node)=>{
+            const metadata = nodeToMetadata(node, true, this.textKey, this.flatMetadata);
+            // Include the specified metadata fields in the top level of the document (to help filter)
+            const populatedMetadata = {};
+            for (const field of this.indexedMetadataFields){
+                populatedMetadata[field] = metadata[field];
+            }
+            return {
+                [this.idKey]: node.id_,
+                [this.embeddingKey]: node.getEmbedding(),
+                [this.textKey]: node.getContent(MetadataMode.NONE) || "",
+                [this.metadataKey]: metadata,
+                ...populatedMetadata
+            };
+        });
+        const collection = await this.ensureCollection();
+        const insertResult = await collection.insertMany(dataToInsert);
+        return Object.values(insertResult.insertedIds).map((id)=>String(id));
+    }
+    /**
+   * Removes specified documents from the AzureCosmosDBMongoDBVectorStore.
+   * @param params Parameters for the delete operation.
+   * @returns A promise that resolves when the documents have been removed.
+   */ async delete(id, deleteOptions) {
+        const collection = await this.ensureCollection();
+        await collection.deleteMany({
+            id: id
+        }, deleteOptions);
+    }
+    async query(query, options) {
+        const pipeline = [
+            {
+                $search: {
+                    cosmosSearch: {
+                        vector: query.queryEmbedding,
+                        path: this.embeddingKey,
+                        k: query.similarityTopK ?? 4,
+                        lSearch: options.lSearch ?? 40,
+                        efSearch: options.efSearch ?? 40,
+                        oversampling: options.oversampling ?? 1.0
+                    },
+                    returnStoredSource: true
+                }
+            }
+        ];
+        const collection = await this.ensureCollection();
+        const cursor = await collection.aggregate(pipeline);
+        const nodes = [];
+        const ids = [];
+        const similarities = [];
+        for await (const res of (await cursor)){
+            const text = res[this.textKey];
+            const score = res.score;
+            const id = res[this.idKey];
+            const metadata = res[this.metadataKey];
+            const node = metadataDictToNode(metadata);
+            node.setContent(text);
+            ids.push(id);
+            nodes.push(node);
+            similarities.push(score);
+        }
+        const result = {
+            nodes,
+            similarities,
+            ids
+        };
+        return result;
+    }
+    /**
+   * Creates an index on the collection with the specified index name during
+   * instance construction.
+   *
+   * Setting the numLists parameter correctly is important for achieving good
+   * accuracy and performance.
+   * Since the vector store uses IVF as the indexing strategy, you should
+   * create the index only after you have loaded a large enough sample
+   * documents to ensure that the centroids for the respective buckets are
+   * faily distributed.
+   *
+   * As for the compression, the following options are available:
+   * - "half" - half precision compression for HNSW and IVF indexes
+   * - "pq" - product quantization compression for DiskANN indexes
+   * More information on the compression options can be found in the:
+   * https://learn.microsoft.com/en-us/azure/cosmos-db/mongodb/vcore/product-quantization
+   *
+   * @param indexType Index Type for Mongo vCore index.
+   * @param dimensions Number of dimensions for vector similarity.
+   *    The maximum number of supported dimensions is 2000.
+   *    If no number is provided, it will be determined automatically by
+   *    embedding a short text.
+   * @param similarity Similarity metric to use with the IVF index.
+   *    Possible options are:
+   *    - CosmosDBSimilarityType.COS (cosine distance)
+   *    - CosmosDBSimilarityType.L2 (Euclidean distance)
+   *    - CosmosDBSimilarityType.IP (inner product)
+   * @returns A promise that resolves when the index has been created.
+   */ async createIndex(dimensions = undefined, indexType = "ivf", similarity = AzureCosmosDBMongoDBSimilarityType.COS) {
+        let vectorLength = dimensions;
+        if (vectorLength === undefined) {
+            vectorLength = 1536;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const cosmosSearchOptions = {
+            kind: "",
+            similarity,
+            dimensions: vectorLength
+        };
+        if (indexType === "hnsw") {
+            cosmosSearchOptions.kind = "vector-hnsw";
+            cosmosSearchOptions.m = this.indexOptions.m ?? 16;
+            cosmosSearchOptions.efConstruction = this.indexOptions.efConstruction ?? 200;
+            if (this.indexOptions.compression === "half") {
+                cosmosSearchOptions.compression = "half";
+            }
+        } else if (indexType === "diskann") {
+            cosmosSearchOptions.kind = "vector-diskann";
+            cosmosSearchOptions.maxDegree = this.indexOptions.maxDegree ?? 40;
+            cosmosSearchOptions.lBuild = this.indexOptions.lBuild ?? 50;
+            if (this.indexOptions.compression === "pq") {
+                cosmosSearchOptions.compression = "pq";
+                cosmosSearchOptions.pqCompressedDims = this.indexOptions.pqCompressedDims ?? this.indexOptions.dimensions;
+                cosmosSearchOptions.pqSampleSize = this.indexOptions.pqSampleSize ?? 1000;
+            }
+        /** Default to IVF index */ } else {
+            cosmosSearchOptions.kind = "vector-ivf";
+            cosmosSearchOptions.numLists = this.indexOptions.numLists ?? 100;
+            if (this.indexOptions.compression === "half") {
+                cosmosSearchOptions.compression = "half";
+            }
+        }
+        const createIndexCommands = {
+            createIndexes: this.collection?.collectionName,
+            indexes: [
+                {
+                    name: this.indexName,
+                    key: {
+                        [this.embeddingKey]: "cosmosSearch"
+                    },
+                    cosmosSearchOptions
+                }
+            ]
+        };
+        await this.database.command(createIndexCommands);
+    }
+    /**
+   * Checks if the specified index name during instance construction exists
+   * on the collection.
+   * @returns A promise that resolves to a boolean indicating if the index exists.
+   */ async checkIndexExists() {
+        const collection = await this.ensureCollection();
+        const indexes = await collection.listIndexes().toArray();
+        return indexes.some((index)=>index.name === this.indexName);
+    }
+    /**
+   * Deletes the index specified during instance construction if it exists.
+   * @returns A promise that resolves when the index has been deleted.
+   */ async deleteIndex(indexName) {
+        const collection = await this.ensureCollection();
+        const indexes = await collection.listIndexes().toArray();
+        const indexToDelete = indexes.find((index)=>index.name === indexName);
+        if (indexToDelete) {
+            await collection.dropIndex(indexName);
+        }
+    }
+}
+
+const USER_AGENT_SUFFIX = "vectorstores-cdbnosql-vectorstore-javascript";
+const DEFAULT_VECTOR_EMBEDDING_POLICY = {
+    vectorEmbeddings: [
+        {
+            path: "/embedding",
+            dataType: VectorEmbeddingDataType.Float32,
+            distanceFunction: VectorEmbeddingDistanceFunction.Cosine,
+            dimensions: 1536
+        }
+    ]
+};
+const DEFAULT_VECTOR_INDEXING_POLICY = [
+    {
+        path: "/embedding",
+        type: VectorIndexType.QuantizedFlat
+    }
+];
+function parseConnectionString(connectionString) {
+    const parts = connectionString.split(";");
+    let endpoint = "";
+    let accountKey = "";
+    parts.forEach((part)=>{
+        const [key, value] = part.split("=");
+        if (key && key.trim() === "AccountEndpoint") {
+            endpoint = value?.trim() ?? "";
+        } else if ((key ?? "").trim() === "AccountKey") {
+            accountKey = value?.trim() ?? "";
+        }
+    });
+    if (!endpoint || !accountKey) {
+        throw new Error("Invalid connection string: missing AccountEndpoint or AccountKey.");
+    }
+    return {
+        endpoint,
+        key: accountKey
+    };
+}
+/**
+ * utility function to build the query string for the CosmosDB query
+ */ function queryBuilder(options) {
+    let initialQuery = "SELECT TOP @k c[@id] as id, c[@text] as text, c[@metadata] as metadata";
+    if (options.includeVectorDistance !== false) {
+        initialQuery += `, VectorDistance(c[@embeddingKey],@embedding) AS SimilarityScore`;
+    }
+    initialQuery += ` FROM c`;
+    if (options.whereClause) {
+        initialQuery += ` WHERE ${options.whereClause}`;
+    }
+    initialQuery += ` ORDER BY VectorDistance(c[@embeddingKey],@embedding)`;
+    return initialQuery;
+}
+class AzureCosmosDBNoSqlVectorStore extends BaseVectorStore {
+    client() {
+        return this.cosmosClient;
+    }
+    constructor(dbConfig){
+        super(dbConfig), this.storesText = true, this.flatMetadata = true;
+        if (!dbConfig.client) {
+            throw new Error("CosmosClient is required for AzureCosmosDBNoSQLVectorStore initialization");
+        }
+        this.cosmosClient = dbConfig.client;
+        const databaseName = dbConfig.databaseName ?? "vectorSearchDB";
+        const containerName = dbConfig.containerName ?? "vectorSearchContainer";
+        this.idKey = dbConfig.idKey ?? "id";
+        this.textKey = dbConfig.textKey ?? "text";
+        this.flatMetadata = dbConfig.flatMetadata ?? true;
+        this.metadataKey = dbConfig.metadataKey ?? "metadata";
+        const vectorEmbeddingPolicy = dbConfig.vectorEmbeddingPolicy ?? DEFAULT_VECTOR_EMBEDDING_POLICY;
+        const indexingPolicy = dbConfig.indexingPolicy ?? {
+            vectorIndexes: DEFAULT_VECTOR_INDEXING_POLICY
+        };
+        this.embeddingKey = vectorEmbeddingPolicy.vectorEmbeddings?.[0]?.path?.slice(1) ?? "";
+        if (!this.embeddingKey) {
+            throw new Error("AzureCosmosDBNoSQLVectorStore requires a valid vectorEmbeddings path");
+        }
+        // Deferring initialization to the first call to `initialize`
+        this.initialize = ()=>{
+            if (this.initPromise === undefined) {
+                this.initPromise = this.init(this.cosmosClient, databaseName, containerName, {
+                    vectorEmbeddingPolicy,
+                    indexingPolicy,
+                    createContainerOptions: dbConfig.createContainerOptions,
+                    createDatabaseOptions: dbConfig.createDatabaseOptions
+                }).catch((error)=>{
+                    console.error("Error during AzureCosmosDBNoSQLVectorStore initialization", error);
+                });
+            }
+            return this.initPromise;
+        };
+    }
+    /**
+   * Static method for creating an instance using a connection string.
+   * If no connection string is provided, it will attempt to use the env variable `AZURE_COSMOSDB_NOSQL_CONNECTION_STRING` as connection string.
+   * @returns Instance of AzureCosmosDBNoSqlVectorStore
+   */ static fromConnectionString(config = {}) {
+        const cosmosConnectionString = config.connectionString || getEnv("AZURE_COSMOSDB_NOSQL_CONNECTION_STRING");
+        if (!cosmosConnectionString) {
+            throw new Error("Azure CosmosDB connection string must be provided");
+        }
+        const { endpoint, key } = parseConnectionString(cosmosConnectionString);
+        const client = new CosmosClient({
+            endpoint,
+            key,
+            userAgentSuffix: USER_AGENT_SUFFIX
+        });
+        return new AzureCosmosDBNoSqlVectorStore({
+            ...config,
+            client
+        });
+    }
+    /**
+   * Static method for creating an instance using a account endpoint and key.
+   * If no endpoint and key  is provided, it will attempt to use the env variable `AZURE_COSMOSDB_NOSQL_ACCOUNT_ENDPOINT` as enpoint and `AZURE_COSMOSDB_NOSQL_ACCOUNT_KEY` as key.
+   * @returns Instance of AzureCosmosDBNoSqlVectorStore
+   */ static fromAccountAndKey(config = {}) {
+        const cosmosEndpoint = config.endpoint || getEnv("AZURE_COSMOSDB_NOSQL_ENDPOINT");
+        const cosmosKey = config.key || getEnv("AZURE_COSMOSDB_NOSQL_KEY");
+        if (!cosmosEndpoint || !cosmosKey) {
+            throw new Error("Azure CosmosDB account endpoint and key must be provided");
+        }
+        const client = new CosmosClient({
+            endpoint: cosmosEndpoint,
+            key: cosmosKey,
+            userAgentSuffix: USER_AGENT_SUFFIX
+        });
+        return new AzureCosmosDBNoSqlVectorStore({
+            ...config,
+            client
+        });
+    }
+    /**
+   * Static method for creating an instance using account endpoint and managed identity.
+   * If no endpoint and credentials are provided, it will attempt to use the env variable `AZURE_COSMOSDB_NOSQL_ACCOUNT_ENDPOINT` as endpoint and use DefaultAzureCredential() as credentials.
+   * @returns Instance of AzureCosmosDBNoSqlVectorStore
+   */ static fromUriAndManagedIdentity(config = {}) {
+        const cosmosEndpoint = config.endpoint || getEnv("AZURE_COSMOSDB_NOSQL_ACCOUNT_ENDPOINT");
+        if (!cosmosEndpoint) {
+            throw new Error("Azure CosmosDB account endpoint must be provided");
+        }
+        const credentials = config.credential ?? new DefaultAzureCredential();
+        const client = new CosmosClient({
+            endpoint: cosmosEndpoint,
+            aadCredentials: credentials,
+            userAgentSuffix: USER_AGENT_SUFFIX
+        });
+        return new AzureCosmosDBNoSqlVectorStore({
+            ...config,
+            client
+        });
+    }
+    /**
+   * Adds document to the CosmosDB container.
+   *
+   * @returns an array of document ids which were added
+   */ async add(nodes) {
+        await this.initialize();
+        if (!nodes || nodes.length === 0) {
+            return [];
+        }
+        const docs = nodes.map((node)=>{
+            const metadata = nodeToMetadata(node, true, this.textKey, this.flatMetadata);
+            return {
+                [this.idKey]: node.id_,
+                [this.embeddingKey]: node.getEmbedding(),
+                [this.textKey]: node.getContent(MetadataMode.NONE) || "",
+                [this.metadataKey]: metadata
+            };
+        });
+        const ids = [];
+        const results = await Promise.allSettled(docs.map((doc)=>this.container.items.create(doc)));
+        for (const result of results){
+            if (result.status === "fulfilled") {
+                ids.push(result.value.resource?.id ?? "");
+            } else {
+                ids.push("error: could not create item");
+            }
+        }
+        return ids;
+    }
+    /**
+   * Delete a document from the CosmosDB container.
+   *
+   * @param refDocId - The id of the document to delete
+   * @param deleteOptions - Any options to pass to the container.item.delete function
+   * @returns Promise that resolves if the delete query did not throw an error.
+   */ async delete(refDocId, deleteOptions) {
+        await this.initialize();
+        await this.container.item(refDocId).delete(deleteOptions);
+    }
+    /**
+   * Performs a vector similarity search query in the CosmosDB container.
+   *
+   * @param query VectorStoreQuery
+   * @returns List of nodes along with similarityScore
+   */ async query(query, options = {}) {
+        await this.initialize();
+        if (!query.queryEmbedding || query.queryEmbedding.length === 0) {
+            throw new Error("queryEmbedding is required for AzureCosmosDBNoSqlVectorStore query");
+        }
+        const params = {
+            vector: query.queryEmbedding,
+            k: query.similarityTopK
+        };
+        const builtQuery = queryBuilder(options);
+        const nodes = [];
+        const ids = [];
+        const similarities = [];
+        const queryResults = await this.container.items.query({
+            query: builtQuery,
+            parameters: [
+                {
+                    name: "@k",
+                    value: params.k
+                },
+                {
+                    name: "@id",
+                    value: this.idKey
+                },
+                {
+                    name: "@text",
+                    value: this.textKey
+                },
+                {
+                    name: "@metadata",
+                    value: this.metadataKey
+                },
+                {
+                    name: "@embedding",
+                    value: params.vector
+                },
+                {
+                    name: "@embeddingKey",
+                    value: this.embeddingKey
+                }
+            ]
+        }).fetchAll();
+        for (const item of queryResults.resources){
+            const node = metadataDictToNode(item["metadata"], {
+                fallback: {
+                    id_: item["id"],
+                    text: item["text"],
+                    ...item["metadata"]
+                }
+            });
+            node.setContent(item["text"]);
+            const nodeId = item["id"];
+            const nodeScore = item["SimilarityScore"];
+            nodes.push(node);
+            ids.push(nodeId);
+            similarities.push(nodeScore);
+        }
+        const result = {
+            nodes,
+            similarities,
+            ids
+        };
+        return result;
+    }
+    /**
+   * Initialize the CosmosDB container.
+   */ async init(client, databaseName, containerName, initOptions) {
+        const { database } = await client.databases.createIfNotExists({
+            ...initOptions?.createDatabaseOptions ?? {},
+            id: databaseName
+        });
+        const { container } = await database.containers.createIfNotExists({
+            ...initOptions?.createContainerOptions ?? {
+                partitionKey: {
+                    paths: [
+                        "/id"
+                    ]
+                }
+            },
+            indexingPolicy: initOptions.indexingPolicy || {
+                vectorIndexes: DEFAULT_VECTOR_INDEXING_POLICY
+            },
+            vectorEmbeddingPolicy: initOptions?.vectorEmbeddingPolicy || DEFAULT_VECTOR_EMBEDDING_POLICY,
+            id: containerName
+        });
+        this.container = container;
+    }
+}
+
+export { AzureAISearchVectorStore, AzureAISearchVectorStoreConfig, AzureCosmosDBMongoDBSimilarityType, AzureCosmosDBMongoDBVectorStore, AzureCosmosDBNoSqlVectorStore, AzureQueryResultSearchBase, AzureQueryResultSearchDefault, AzureQueryResultSearchHybrid, AzureQueryResultSearchSemanticHybrid, AzureQueryResultSearchSparse, IndexManagement, MetadataIndexFieldType, SimpleCosmosDBReader };