@vectorstores/azure 0.1.0

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

@@ -0,0 +1,585 @@
+import { SqlQuerySpec, CosmosClient, DatabaseRequest, ContainerRequest, VectorEmbeddingPolicy, IndexingPolicy } from '@azure/cosmos';
+import { BaseReader, Document, BaseNode, BaseVectorStore, VectorStoreBaseParams, MetadataFilters, VectorStoreQuery, VectorStoreQueryResult } from '@vectorstores/core';
+export * from './storage.js';
+import { AzureKeyCredential, SearchIndexClient, SearchClient, LexicalAnalyzerName, KnownVectorSearchCompressionKind, KnownVectorSearchAlgorithmKind, VectorizedQuery } from '@azure/search-documents';
+import { DefaultAzureCredential, ManagedIdentityCredential, TokenCredential } from '@azure/identity';
+import { MongoClient, Collection } from 'mongodb';
+
+type SimpleCosmosDBReaderLoaderConfig = {
+    /**
+     * The name of the database to read.
+     */
+    databaseName: string;
+    /**
+     * The name of the container to read.
+     */
+    containerName: string;
+    /**
+     * An array of field names to retrieve from each document. Defaults to ["text"].
+     */
+    fields?: string[];
+    /**
+     * The separator to join multiple field values. Defaults to an empty string.
+     */
+    fieldSeparator?: string;
+    /**
+     * A custom query to filter the documents. Defaults to `SELECT * FROM c`.
+     */
+    query?: string | SqlQuerySpec;
+    /**
+     * An optional array of metadata field names. If specified extracts this information as metadata.
+     */
+    metadataFields?: string[];
+};
+/**
+ * Read data from CosmosDB.
+ */
+declare class SimpleCosmosDBReader implements BaseReader {
+    /**
+     * The CosmosDB client.
+     */
+    private client;
+    constructor(client: CosmosClient);
+    /**
+     * Loads data from a Cosmos DB container
+     * @returns {Promise<Document[]>}
+     */
+    loadData(config: SimpleCosmosDBReaderLoaderConfig): Promise<Document[]>;
+}
+
+type R = Record<"id" | "chunk" | "embedding" | "doc_id" | "metadata", unknown>;
+declare const AzureAISearchVectorStoreConfig: {
+    ALGORITHM_HNSW_NAME: string;
+    ALGORITHM_EXHAUSTIVE_KNN_NAME: string;
+    PROFILE_HNSW_NAME: string;
+    PROFILE_EXHAUSTIVE_KNN_NAME: string;
+    COMPRESSION_TYPE_SCALAR: string;
+    COMPRESSION_TYPE_BINARY: string;
+    SEMANTIC_CONFIG_NAME: string;
+    DEFAULT_MAX_BATCH_SIZE: number;
+    DEFAULT_MAX_MB_SIZE: number;
+    DEFAULT_USER_AGENT_PREFIX: string;
+    DEFAULT_AZURE_API_VERSION: string;
+};
+
+/**
+ * Enumeration representing the supported index management operations
+ */
+declare enum IndexManagement {
+    NO_VALIDATION = "NoValidation",
+    VALIDATE_INDEX = "ValidateIndex",
+    CREATE_IF_NOT_EXISTS = "CreateIfNotExists"
+}
+/**
+ * Enumeration representing the supported types for metadata fields in an
+ * Azure AI Search Index, corresponds with types supported in a flat
+ * metadata dictionary.
+ */
+declare enum MetadataIndexFieldType {
+    STRING = "Edm.String",
+    BOOLEAN = "Edm.Boolean",
+    INT32 = "Edm.Int32",
+    INT64 = "Edm.Int64",
+    DOUBLE = "Edm.Double",
+    COLLECTION = "Collection(Edm.String)"
+}
+/**
+ * Embeddings and documents are stored in an Azure AI Search index,
+ * a merge or upload approach is used when adding embeddings.
+ * When adding multiple embeddings the index is updated by this vector store
+ * in batches of 10 documents, very large nodes may result in failure due to
+ * the batch byte size being exceeded.
+ */
+interface AzureAISearchOptions<T extends R> {
+    userAgent?: string;
+    credential?: AzureKeyCredential | DefaultAzureCredential | ManagedIdentityCredential;
+    endpoint?: string;
+    key?: string;
+    serviceApiVersion?: string;
+    indexName?: string;
+    indexClient?: SearchIndexClient;
+    indexManagement?: IndexManagement;
+    searchClient?: SearchClient<T>;
+    languageAnalyzer?: LexicalAnalyzerName;
+    compressionType?: KnownVectorSearchCompressionKind;
+    embeddingDimensionality?: number;
+    vectorAlgorithmType?: KnownVectorSearchAlgorithmKind;
+    /**
+     * Index field storing the id
+     */
+    idFieldKey?: string | undefined;
+    /**
+     * Index field storing the node text
+     */
+    chunkFieldKey?: string | undefined;
+    /**
+     * Index field storing the embedding vector
+     */
+    embeddingFieldKey?: string | undefined;
+    /**
+     * Index field storing node metadata as a json string.
+     * Schema is arbitrary, to filter on metadata values they must be stored
+     * as separate fields in the index, use filterable_metadata_field_keys
+     * to specify the metadata values that should be stored in these filterable fields
+     */
+    metadataStringFieldKey?: string | undefined;
+    /**
+     * Index field storing doc_id
+     */
+    docIdFieldKey?: string | undefined;
+    /**
+     * List of index fields that should be hidden from the client.
+     * This is useful for fields that are not needed for retrieving,
+     * but are used for similarity search, like the embedding field.
+     */
+    hiddenFieldKeys?: string[] | undefined;
+    filterableMetadataFieldKeys?: FilterableMetadataFieldKeysType | undefined;
+    /**
+     * (Optional) function used to map document fields to the AI search index fields
+     * If none is specified a default mapping is provided which uses
+     *  the field keys. The keys in the enriched document are:
+     *   `["id", "chunk", "embedding", "metadata"]`.
+     *
+     *   The default mapping is:
+     *   - `"id"` to idFieldKey
+     *   - `"chunk"` to chunkFieldKey
+     *   - `"embedding"` to embeddingFieldKey
+     *   - `"metadata"` to metadataFieldKey
+     * @param enrichedDoc The enriched document
+     * @param metadata The metadata of the document
+     * @returns The mapped index document
+     */
+    indexMapping?: (enrichedDoc: BaseNode, metadata: Record<string, unknown>) => T;
+}
+type FilterableMetadataFieldKeysType = Array<string> | Map<string, string> | Map<string, [string, MetadataIndexFieldType]>;
+/**
+ * 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 });
+ */
+declare class AzureAISearchVectorStore<T extends R> extends BaseVectorStore {
+    #private;
+    storesText: boolean;
+    _searchClient: SearchClient<T> | undefined;
+    _indexClient: SearchIndexClient | undefined;
+    flatMetadata: boolean;
+    constructor(options: AzureAISearchOptions<T> & VectorStoreBaseParams);
+    createSearchIndexClient(options: AzureAISearchOptions<T>): void;
+    createSearchClient(options: AzureAISearchOptions<T>): void;
+    /**
+     * Get search client
+     * @returns Azure AI Search client. See {@link SearchClient}
+     */
+    client(): SearchClient<T> | undefined;
+    /**
+     * Get index client
+     * @returns Azure AI Search index client. See {@link SearchIndexClient}
+     */
+    indexClient(): SearchIndexClient | undefined;
+    /**
+     * 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
+     */
+    add(nodes: BaseNode[]): Promise<string[]>;
+    /**
+     * 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
+     */
+    delete(refDocId: string): Promise<void>;
+    /**
+     * 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
+     */
+    getNodes(nodeIds?: string[], filters?: MetadataFilters, limit?: number): Promise<BaseNode[]>;
+    query(query: VectorStoreQuery & {
+        queryStr: string;
+    }): Promise<VectorStoreQueryResult>;
+}
+
+/** Azure Cosmos DB for MongoDB vCore Similarity type. */
+declare const AzureCosmosDBMongoDBSimilarityType: {
+    /** Cosine similarity */
+    readonly COS: "COS";
+    /** Inner - product */
+    readonly IP: "IP";
+    /** Euclidian distance */
+    readonly L2: "L2";
+};
+/** Azure Cosmos DB for MongoDB vCore Similarity type. */
+type AzureCosmosDBMongoDBSimilarityType = (typeof AzureCosmosDBMongoDBSimilarityType)[keyof typeof AzureCosmosDBMongoDBSimilarityType];
+/** Azure Cosmos DB for MongoDB vCore Index Options. */
+type AzureCosmosDBMongoDBIndexOptions = {
+    readonly indexType?: "ivf" | "hnsw" | "diskann" | undefined;
+    /** Number of clusters that the inverted file (IVF) index uses to group the vector data. */
+    readonly numLists?: number | undefined;
+    /** Number of dimensions for vector similarity. */
+    readonly dimensions?: number | undefined;
+    /** Similarity metric to use with the IVF index. */
+    readonly similarity?: AzureCosmosDBMongoDBSimilarityType | undefined;
+    /** The max number of connections per layer with the HNSW index. */
+    readonly m?: number | undefined;
+    /** The size of the dynamic candidate list for constructing the graph with the HNSW index. */
+    readonly efConstruction?: number | undefined;
+    /** Max number of neighbors withe the Diskann idnex */
+    readonly maxDegree?: number | undefined;
+    /** L value for index building withe the Diskann idnex */
+    readonly lBuild?: number | undefined;
+    /** Compression value for type of vector index compression */
+    readonly compression?: "half" | "pq" | undefined;
+    /** PqCompressedDims value for dimensions after PQ compression */
+    readonly pqCompressedDims?: number | undefined;
+    /** PqSampleSize value for number of sample vectors for PQ centroid training */
+    readonly pqSampleSize?: number | undefined;
+};
+/** Azure Cosmos DB for MongoDB vCore Query Options. */
+interface AzureCosmosDBMongoDBQueryOptions {
+    /** Specifies the size of the dynamic candidate list for search. Used for DiskANN */
+    lSearch?: number;
+    /** The size of the dynamic candidate list for search (40 by default). Used for HNSW */
+    efSearch?: number;
+    /** Oversampling specifies how many more candidate vectors to retrieve from the compressed index than k */
+    oversampling?: number;
+}
+/**
+ * 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.
+ */
+declare class AzureCosmosDBMongoDBVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    flatMetadata: boolean;
+    dbName: string;
+    collectionName: string;
+    indexedMetadataFields: string[];
+    /**
+     * The used MongoClient. If not given, a new MongoClient is created based on the MONGODB_URI env variable.
+     */
+    mongodbClient: MongoClient;
+    indexName: string;
+    embeddingKey: string;
+    idKey: string;
+    textKey: string;
+    metadataKey: string;
+    indexOptions: AzureCosmosDBMongoDBIndexOptions;
+    private collection?;
+    private database;
+    constructor(init: Partial<AzureCosmosDBMongoDBVectorStore> & {
+        dbName: string;
+        collectionName: string;
+        indexedMetadataFields?: string[];
+    } & VectorStoreBaseParams);
+    client(): MongoClient;
+    ensureCollection(): Promise<Collection>;
+    add(nodes: BaseNode[]): Promise<string[]>;
+    /**
+     * Removes specified documents from the AzureCosmosDBMongoDBVectorStore.
+     * @param params Parameters for the delete operation.
+     * @returns A promise that resolves when the documents have been removed.
+     */
+    delete(id: string, deleteOptions?: object): Promise<void>;
+    query(query: VectorStoreQuery, options: AzureCosmosDBMongoDBQueryOptions): Promise<VectorStoreQueryResult>;
+    /**
+     * 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.
+     */
+    createIndex(dimensions?: number | undefined, indexType?: "ivf" | "hnsw" | "diskann", similarity?: AzureCosmosDBMongoDBSimilarityType): Promise<void>;
+    /**
+     * 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.
+     */
+    checkIndexExists(): Promise<boolean>;
+    /**
+     * Deletes the index specified during instance construction if it exists.
+     * @returns A promise that resolves when the index has been deleted.
+     */
+    deleteIndex(indexName: string): Promise<void>;
+}
+
+/** Azure Cosmos DB for NoSQL database creation options. */
+type AzureCosmosDBNoSqlCreateDatabaseOptions = Partial<Omit<DatabaseRequest, "id">>;
+/** Azure Cosmos DB for NoSQL container creation options. */
+type AzureCosmosDBNoSqlCreateContainerOptions = Partial<Omit<ContainerRequest, "id" | "vectorEmbeddingPolicy" | "indexingPolicy">>;
+interface AzureCosmosDBNoSQLInitOptions {
+    readonly vectorEmbeddingPolicy?: VectorEmbeddingPolicy | undefined;
+    readonly indexingPolicy?: IndexingPolicy | undefined;
+    readonly createContainerOptions?: AzureCosmosDBNoSqlCreateContainerOptions | undefined;
+    readonly createDatabaseOptions?: AzureCosmosDBNoSqlCreateDatabaseOptions | undefined;
+}
+/**
+ * Configuration options for the `AzureCosmosDBNoSQLVectorStore` constructor.
+ */
+interface AzureCosmosDBNoSQLConfig extends AzureCosmosDBNoSQLInitOptions {
+    client?: CosmosClient;
+    readonly databaseName?: string;
+    readonly containerName?: string;
+    readonly textKey?: string;
+    readonly metadataKey?: string;
+    readonly flatMetadata?: boolean;
+    readonly idKey?: string;
+}
+/**
+ * Query options for the `AzureCosmosDBNoSQLVectorStore.query` method.
+ * @property includeEmbeddings - Whether to include the embeddings in the result. Default false
+ * @property includeVectorDistance - Whether to include the vector distance in the result. Default true
+ * @property whereClause - The where clause to use in the query. While writing this clause, use `c` as the alias for the container and do not include the `WHERE` keyword.
+ */
+interface AzureCosmosQueryOptions {
+    includeVectorDistance?: boolean;
+    whereClause?: string;
+}
+declare class AzureCosmosDBNoSqlVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    private initPromise?;
+    private container;
+    /**
+     * The CosmosDB client. This is either passed in or created.
+     */
+    cosmosClient: CosmosClient;
+    /**
+     * The key to use for the text field in the CosmosDB container.
+     * Default: "text"
+     */
+    textKey: string;
+    flatMetadata: boolean;
+    /**
+     * The key to use for the id field in the CosmosDB container.
+     * Default: "id"
+     */
+    idKey: string;
+    /**
+     * The key to use for the metadata field in the CosmosDB container.
+     * Default: "metadata"
+     */
+    metadataKey: string;
+    /**
+     * The key to use for the vector embedding field in the CosmosDB container.
+     * Default: "embedding"
+     */
+    embeddingKey: string;
+    private initialize;
+    client(): unknown;
+    constructor(dbConfig: AzureCosmosDBNoSQLConfig & VectorStoreBaseParams);
+    /**
+     * 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?: {
+        connectionString?: string;
+    } & AzureCosmosDBNoSQLConfig & VectorStoreBaseParams): AzureCosmosDBNoSqlVectorStore;
+    /**
+     * 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?: {
+        endpoint?: string;
+        key?: string;
+    } & AzureCosmosDBNoSQLConfig & VectorStoreBaseParams): AzureCosmosDBNoSqlVectorStore;
+    /**
+     * 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?: {
+        endpoint?: string;
+        credential?: TokenCredential;
+    } & AzureCosmosDBNoSQLConfig & VectorStoreBaseParams): AzureCosmosDBNoSqlVectorStore;
+    /**
+     * Adds document to the CosmosDB container.
+     *
+     * @returns an array of document ids which were added
+     */
+    add(nodes: BaseNode[]): Promise<string[]>;
+    /**
+     * 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.
+     */
+    delete(refDocId: string, deleteOptions?: object): Promise<void>;
+    /**
+     * Performs a vector similarity search query in the CosmosDB container.
+     *
+     * @param query VectorStoreQuery
+     * @returns List of nodes along with similarityScore
+     */
+    query(query: VectorStoreQuery, options?: AzureCosmosQueryOptions): Promise<VectorStoreQueryResult>;
+    /**
+     * Initialize the CosmosDB container.
+     */
+    private init;
+}
+
+declare class AzureQueryResultSearchBase<T extends R> {
+    protected _query: VectorStoreQuery;
+    fieldMapping: Record<string, string>;
+    odataFilter: string | undefined;
+    searchClient: SearchClient<T> | undefined;
+    constructor(query: VectorStoreQuery, fieldMapping: Record<string, string>, odataFilter: string | undefined, searchClient: SearchClient<T> | undefined);
+    get selectFields(): string[];
+    createSearchQuery(): string;
+    protected createQueryVector(): VectorizedQuery<T>[] | null;
+    protected _createQueryResult(searchQuery: string, vectorQueries: VectorizedQuery<T>[] | null): Promise<VectorStoreQueryResult>;
+    search(): Promise<VectorStoreQueryResult>;
+}
+declare class AzureQueryResultSearchDefault<T extends R> extends AzureQueryResultSearchBase<T> {
+    createQueryVector(): VectorizedQuery<T>[];
+}
+declare class AzureQueryResultSearchSparse<T extends R> extends AzureQueryResultSearchBase<T> {
+    createSearchQuery(): string;
+}
+declare class AzureQueryResultSearchHybrid<T extends R> extends AzureQueryResultSearchBase<T> {
+    createQueryVector(): VectorizedQuery<T>[];
+    createSearchQuery(): string;
+}
+declare class AzureQueryResultSearchSemanticHybrid<T extends R> extends AzureQueryResultSearchHybrid<T> {
+    createQueryVector(): VectorizedQuery<T>[];
+    _createQueryResult(searchQuery: string, vectorQueries: VectorizedQuery<T>[]): Promise<VectorStoreQueryResult>;
+}
+
+export { AzureAISearchVectorStore, AzureAISearchVectorStoreConfig, AzureCosmosDBMongoDBSimilarityType, AzureCosmosDBMongoDBVectorStore, AzureCosmosDBNoSqlVectorStore, AzureQueryResultSearchBase, AzureQueryResultSearchDefault, AzureQueryResultSearchHybrid, AzureQueryResultSearchSemanticHybrid, AzureQueryResultSearchSparse, IndexManagement, MetadataIndexFieldType, SimpleCosmosDBReader };
+export type { AzureAISearchOptions, AzureCosmosDBMongoDBIndexOptions, AzureCosmosDBMongoDBQueryOptions, AzureCosmosDBNoSQLConfig, AzureCosmosDBNoSQLInitOptions, AzureCosmosDBNoSqlCreateContainerOptions, AzureCosmosDBNoSqlCreateDatabaseOptions, AzureCosmosQueryOptions, FilterableMetadataFieldKeysType, R, SimpleCosmosDBReaderLoaderConfig };