Variable configureConst

configure: {
    dataType: {
        BLOB: "blob";
        BOOLEAN: "boolean";
        BOOLEAN_ARRAY: "boolean[]";
        DATE: "date";
        DATE_ARRAY: "date[]";
        GEO_COORDINATES: "geoCoordinates";
        INT: "int";
        INT_ARRAY: "int[]";
        NUMBER: "number";
        NUMBER_ARRAY: "number[]";
        OBJECT: "object";
        OBJECT_ARRAY: "object[]";
        PHONE_NUMBER: "phoneNumber";
        TEXT: "text";
        TEXT_ARRAY: "text[]";
        UUID: "uuid";
        UUID_ARRAY: "uuid[]";
    };
    generative: {
        azureOpenAI: ((config) => ModuleConfig<"generative-openai", GenerativeAzureOpenAIConfig>);
        cohere: ((config?) => ModuleConfig<"generative-cohere", undefined | GenerativeCohereConfig>);
        databricks: ((config) => ModuleConfig<"generative-databricks", GenerativeDatabricksConfig>);
        google: ((config?) => ModuleConfig<"generative-google", undefined | GenerativeGoogleConfig>);
        openAI: ((config?) => ModuleConfig<"generative-openai", undefined | GenerativeOpenAIConfig>);
        palm: ((config?) => ModuleConfig<"generative-palm", undefined | GenerativeGoogleConfig>);
        anthropic(config?): ModuleConfig<"generative-anthropic", undefined | GenerativeAnthropicConfig>;
        anyscale(config?): ModuleConfig<"generative-anyscale", undefined | GenerativeAnyscaleConfig>;
        aws(config): ModuleConfig<"generative-aws", GenerativeAWSConfig>;
        friendliai(config?): ModuleConfig<"generative-friendliai", undefined | GenerativeFriendliAIConfig>;
        mistral(config?): ModuleConfig<"generative-mistral", undefined | GenerativeMistralConfig>;
        ollama(config?): ModuleConfig<"generative-ollama", undefined | GenerativeOllamaConfig>;
    };
    invertedIndex: ((options) => {
        bm25?: {
            b?: number;
            k1?: number;
        };
        cleanupIntervalSeconds?: number;
        indexNullState?: boolean;
        indexPropertyLength?: boolean;
        indexTimestamps?: boolean;
        stopwords?: {
            additions?: (undefined | string)[];
            preset?: string;
            removals?: (undefined | string)[];
        };
    });
    multiTenancy: ((options?) => {
        autoTenantActivation?: boolean;
        autoTenantCreation?: boolean;
        enabled?: boolean;
    });
    replication: ((options) => {
        asyncEnabled?: boolean;
        deletionStrategy?: ReplicationDeletionStrategy;
        factor?: number;
    });
    reranker: {
        cohere: ((config?) => ModuleConfig<"reranker-cohere", undefined | RerankerCohereConfig>);
        jinaai: ((config?) => ModuleConfig<"reranker-jinaai", undefined | RerankerJinaAIConfig>);
        transformers: (() => ModuleConfig<"reranker-transformers", Record<string, never>>);
        voyageAI: ((config?) => ModuleConfig<"reranker-voyageai", undefined | RerankerVoyageAIConfig>);
    };
    sharding: ((options) => ShardingConfigCreate);
    tokenization: {
        FIELD: "field";
        GSE: "gse";
        KAGOME_KR: "kagome_kr";
        LOWERCASE: "lowercase";
        TRIGRAM: "trigram";
        WHITESPACE: "whitespace";
        WORD: "word";
    };
    vectorDistances: {
        COSINE: "cosine";
        DOT: "dot";
        HAMMING: "hamming";
        L2_SQUARED: "l2-squared";
    };
    vectorIndex: {
        dynamic: ((opts?) => ModuleConfig<"dynamic", undefined | {
            distance?: VectorDistance;
            flat?: {
                distance?: VectorDistance;
                quantizer?: {
                    cache?: (...) | (...) | (...);
                    rescoreLimit?: (...) | (...);
                    type?: (...) | (...);
                };
                type?: "flat";
                vectorCacheMaxObjects?: number;
            };
            hnsw?: {
                cleanupIntervalSeconds?: number;
                distance?: VectorDistance;
                dynamicEfFactor?: number;
                dynamicEfMax?: number;
                dynamicEfMin?: number;
                ef?: number;
                efConstruction?: number;
                filterStrategy?: VectorIndexFilterStrategy;
                flatSearchCutoff?: number;
                maxConnections?: number;
                quantizer?: {
                    cache?: (...) | (...) | (...);
                    rescoreLimit?: (...) | (...);
                    type?: (...) | (...);
                } | {
                    bitCompression?: (...) | (...) | (...);
                    centroids?: (...) | (...);
                    encoder?: (...) | (...);
                    segments?: (...) | (...);
                    trainingLimit?: (...) | (...);
                    type?: (...) | (...);
                } | {
                    rescoreLimit?: (...) | (...);
                    trainingLimit?: (...) | (...);
                    type?: (...) | (...);
                };
                skip?: boolean;
                type?: "hnsw";
                vectorCacheMaxObjects?: number;
            };
            threshold?: number;
            type?: "dynamic";
        }>);
        flat: ((opts?) => ModuleConfig<"flat", undefined | {
            distance?: VectorDistance;
            quantizer?: {
                cache?: boolean;
                rescoreLimit?: number;
                type?: "bq";
            };
            type?: "flat";
            vectorCacheMaxObjects?: number;
        }>);
        hnsw: ((opts?) => ModuleConfig<"hnsw", undefined | {
            cleanupIntervalSeconds?: number;
            distance?: VectorDistance;
            dynamicEfFactor?: number;
            dynamicEfMax?: number;
            dynamicEfMin?: number;
            ef?: number;
            efConstruction?: number;
            filterStrategy?: VectorIndexFilterStrategy;
            flatSearchCutoff?: number;
            maxConnections?: number;
            quantizer?: {
                cache?: boolean;
                rescoreLimit?: number;
                type?: "bq";
            } | {
                bitCompression?: boolean;
                centroids?: number;
                encoder?: {
                    distribution?: (...) | (...);
                    type?: (...) | (...);
                };
                segments?: number;
                trainingLimit?: number;
                type?: "pq";
            } | {
                rescoreLimit?: number;
                trainingLimit?: number;
                type?: "sq";
            };
            skip?: boolean;
            type?: "hnsw";
            vectorCacheMaxObjects?: number;
        }>);
        quantizer: {
            bq: ((options?) => QuantizerRecursivePartial<BQConfig>);
            pq: ((options?) => QuantizerRecursivePartial<PQConfig>);
            sq: ((options?) => QuantizerRecursivePartial<SQConfig>);
        };
    };
    vectorizer: {
        img2VecNeural: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "img2vec-neural">);
        multi2VecBind: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-bind">);
        multi2VecClip: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-clip">);
        multi2VecCohere: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-cohere">);
        multi2VecGoogle: (<N, I>(opts) => VectorConfigCreate<never, N, I, "multi2vec-google">);
        multi2VecJinaAI: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-jinaai">);
        multi2VecPalm: (<N, I>(opts) => VectorConfigCreate<never, N, I, "multi2vec-palm">);
        multi2VecVoyageAI: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-voyageai">);
        none: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "none">);
        ref2VecCentroid: (<N, I>(opts) => VectorConfigCreate<never, N, I, "ref2vec-centroid">);
        text2VecAWS: (<T, N, I>(opts) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-aws">);
        text2VecAzureOpenAI: (<T, N, I>(opts) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-azure-openai">);
        text2VecCohere: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-cohere">);
        text2VecContextionary: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-contextionary">);
        text2VecDatabricks: (<T, N, I>(opts) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-databricks">);
        text2VecGPT4All: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-gpt4all">);
        text2VecGoogle: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-google">);
        text2VecHuggingFace: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-huggingface">);
        text2VecJinaAI: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-jinaai">);
        text2VecMistral: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-mistral">);
        text2VecOllama: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-ollama">);
        text2VecOpenAI: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-openai">);
        text2VecPalm: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-palm">);
        text2VecTransformers: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-transformers">);
        text2VecVoyageAI: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-voyageai">);
        text2VecWeaviate: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-weaviate">);
    };
} = ...

Type declaration

  • dataType: {
        BLOB: "blob";
        BOOLEAN: "boolean";
        BOOLEAN_ARRAY: "boolean[]";
        DATE: "date";
        DATE_ARRAY: "date[]";
        GEO_COORDINATES: "geoCoordinates";
        INT: "int";
        INT_ARRAY: "int[]";
        NUMBER: "number";
        NUMBER_ARRAY: "number[]";
        OBJECT: "object";
        OBJECT_ARRAY: "object[]";
        PHONE_NUMBER: "phoneNumber";
        TEXT: "text";
        TEXT_ARRAY: "text[]";
        UUID: "uuid";
        UUID_ARRAY: "uuid[]";
    }
    • BLOB: "blob"
    • BOOLEAN: "boolean"
    • BOOLEAN_ARRAY: "boolean[]"
    • DATE: "date"
    • DATE_ARRAY: "date[]"
    • GEO_COORDINATES: "geoCoordinates"
    • INT: "int"
    • INT_ARRAY: "int[]"
    • NUMBER: "number"
    • NUMBER_ARRAY: "number[]"
    • OBJECT: "object"
    • OBJECT_ARRAY: "object[]"
    • PHONE_NUMBER: "phoneNumber"
    • TEXT: "text"
    • TEXT_ARRAY: "text[]"
    • UUID: "uuid"
    • UUID_ARRAY: "uuid[]"
  • generative: {
        azureOpenAI: ((config) => ModuleConfig<"generative-openai", GenerativeAzureOpenAIConfig>);
        cohere: ((config?) => ModuleConfig<"generative-cohere", undefined | GenerativeCohereConfig>);
        databricks: ((config) => ModuleConfig<"generative-databricks", GenerativeDatabricksConfig>);
        google: ((config?) => ModuleConfig<"generative-google", undefined | GenerativeGoogleConfig>);
        openAI: ((config?) => ModuleConfig<"generative-openai", undefined | GenerativeOpenAIConfig>);
        palm: ((config?) => ModuleConfig<"generative-palm", undefined | GenerativeGoogleConfig>);
        anthropic(config?): ModuleConfig<"generative-anthropic", undefined | GenerativeAnthropicConfig>;
        anyscale(config?): ModuleConfig<"generative-anyscale", undefined | GenerativeAnyscaleConfig>;
        aws(config): ModuleConfig<"generative-aws", GenerativeAWSConfig>;
        friendliai(config?): ModuleConfig<"generative-friendliai", undefined | GenerativeFriendliAIConfig>;
        mistral(config?): ModuleConfig<"generative-mistral", undefined | GenerativeMistralConfig>;
        ollama(config?): ModuleConfig<"generative-ollama", undefined | GenerativeOllamaConfig>;
    }
  • invertedIndex: ((options) => {
        bm25?: {
            b?: number;
            k1?: number;
        };
        cleanupIntervalSeconds?: number;
        indexNullState?: boolean;
        indexPropertyLength?: boolean;
        indexTimestamps?: boolean;
        stopwords?: {
            additions?: (undefined | string)[];
            preset?: string;
            removals?: (undefined | string)[];
        };
    })

    Create an InvertedIndexConfigCreate object to be used when defining the configuration of the keyword searching algorithm of your collection.

    See the docs for details!

      • (options): {
            bm25?: {
                b?: number;
                k1?: number;
            };
            cleanupIntervalSeconds?: number;
            indexNullState?: boolean;
            indexPropertyLength?: boolean;
            indexTimestamps?: boolean;
            stopwords?: {
                additions?: (undefined | string)[];
                preset?: string;
                removals?: (undefined | string)[];
            };
        }

      • Parameters

        • options: {
              bm25b?: number;
              bm25k1?: number;
              cleanupIntervalSeconds?: number;
              indexNullState?: boolean;
              indexPropertyLength?: boolean;
              indexTimestamps?: boolean;
              stopwordsAdditions?: string[];
              stopwordsPreset?: "none" | "en";
              stopwordsRemovals?: string[];
          }
          • Optional bm25b?: number

            The BM25 b parameter.

          • Optional bm25k1?: number

            The BM25 k1 parameter.

          • Optional cleanupIntervalSeconds?: number

            The interval in seconds at which the inverted index is cleaned up.

          • Optional indexNullState?: boolean

            Whether to index the null state of properties.

          • Optional indexPropertyLength?: boolean

            Whether to index the length of properties.

          • Optional indexTimestamps?: boolean

            Whether to index timestamps.

          • Optional stopwordsAdditions?: string[]

            Additional stopwords to add.

          • Optional stopwordsPreset?: "none" | "en"

            The stopwords preset to use.

          • Optional stopwordsRemovals?: string[]

            Stopwords to remove.

        Returns {
            bm25?: {
                b?: number;
                k1?: number;
            };
            cleanupIntervalSeconds?: number;
            indexNullState?: boolean;
            indexPropertyLength?: boolean;
            indexTimestamps?: boolean;
            stopwords?: {
                additions?: (undefined | string)[];
                preset?: string;
                removals?: (undefined | string)[];
            };
        }

        • Optional bm25?: {
              b?: number;
              k1?: number;
          }
          • Optional b?: number
          • Optional k1?: number
        • Optional cleanupIntervalSeconds?: number
        • Optional indexNullState?: boolean
        • Optional indexPropertyLength?: boolean
        • Optional indexTimestamps?: boolean
        • Optional stopwords?: {
              additions?: (undefined | string)[];
              preset?: string;
              removals?: (undefined | string)[];
          }
          • Optional additions?: (undefined | string)[]
          • Optional preset?: string
          • Optional removals?: (undefined | string)[]
  • multiTenancy: ((options?) => {
        autoTenantActivation?: boolean;
        autoTenantCreation?: boolean;
        enabled?: boolean;
    })

    Create a MultiTenancyConfigCreate object to be used when defining the multi-tenancy configuration of your collection.

      • (options?): {
            autoTenantActivation?: boolean;
            autoTenantCreation?: boolean;
            enabled?: boolean;
        }

      • Parameters

        • Optional options: {
              autoTenantActivation?: boolean;
              autoTenantCreation?: boolean;
              enabled?: boolean;
          }
          • Optional autoTenantActivation?: boolean

            Whether auto-tenant activation is enabled. Default is false.

          • Optional autoTenantCreation?: boolean

            Whether auto-tenant creation is enabled. Default is false.

          • Optional enabled?: boolean

            Whether multi-tenancy is enabled. Default is true.

        Returns {
            autoTenantActivation?: boolean;
            autoTenantCreation?: boolean;
            enabled?: boolean;
        }

        • Optional autoTenantActivation?: boolean
        • Optional autoTenantCreation?: boolean
        • Optional enabled?: boolean
  • replication: ((options) => {
        asyncEnabled?: boolean;
        deletionStrategy?: ReplicationDeletionStrategy;
        factor?: number;
    })

    Create a ReplicationConfigCreate object to be used when defining the replication configuration of your collection.

    NOTE: You can only use one of Sharding or Replication, not both.

    See the docs for more details.

      • (options): {
            asyncEnabled?: boolean;
            deletionStrategy?: ReplicationDeletionStrategy;
            factor?: number;
        }

      • Parameters

        • options: {
              asyncEnabled?: boolean;
              deletionStrategy?: ReplicationDeletionStrategy;
              factor?: number;
          }
          • Optional asyncEnabled?: boolean

            Whether asynchronous replication is enabled. Default is false.

          • Optional deletionStrategy?: ReplicationDeletionStrategy

            The deletion strategy when replication conflicts are detected between deletes and reads.

          • Optional factor?: number

            The replication factor. Default is 1.

        Returns {
            asyncEnabled?: boolean;
            deletionStrategy?: ReplicationDeletionStrategy;
            factor?: number;
        }

  • reranker: {
        cohere: ((config?) => ModuleConfig<"reranker-cohere", undefined | RerankerCohereConfig>);
        jinaai: ((config?) => ModuleConfig<"reranker-jinaai", undefined | RerankerJinaAIConfig>);
        transformers: (() => ModuleConfig<"reranker-transformers", Record<string, never>>);
        voyageAI: ((config?) => ModuleConfig<"reranker-voyageai", undefined | RerankerVoyageAIConfig>);
    }
  • sharding: ((options) => ShardingConfigCreate)

    Create a ShardingConfigCreate object to be used when defining the sharding configuration of your collection.

    NOTE: You can only use one of Sharding or Replication, not both.

    See the docs for more details.

      • (options): ShardingConfigCreate

      • Parameters

        • options: {
              desiredCount?: number;
              desiredVirtualCount?: number;
              virtualPerPhysical?: number;
          }
          • Optional desiredCount?: number

            The desired number of physical shards.

          • Optional desiredVirtualCount?: number

            The desired number of virtual shards.

          • Optional virtualPerPhysical?: number

            The number of virtual shards per physical shard.

        Returns ShardingConfigCreate

  • tokenization: {
        FIELD: "field";
        GSE: "gse";
        KAGOME_KR: "kagome_kr";
        LOWERCASE: "lowercase";
        TRIGRAM: "trigram";
        WHITESPACE: "whitespace";
        WORD: "word";
    }
    • FIELD: "field"
    • GSE: "gse"
    • KAGOME_KR: "kagome_kr"
    • LOWERCASE: "lowercase"
    • TRIGRAM: "trigram"
    • WHITESPACE: "whitespace"
    • WORD: "word"
  • vectorDistances: {
        COSINE: "cosine";
        DOT: "dot";
        HAMMING: "hamming";
        L2_SQUARED: "l2-squared";
    }
    • COSINE: "cosine"
    • DOT: "dot"
    • HAMMING: "hamming"
    • L2_SQUARED: "l2-squared"
  • vectorIndex: {
        dynamic: ((opts?) => ModuleConfig<"dynamic", undefined | {
            distance?: VectorDistance;
            flat?: {
                distance?: VectorDistance;
                quantizer?: {
                    cache?: (...) | (...) | (...);
                    rescoreLimit?: (...) | (...);
                    type?: (...) | (...);
                };
                type?: "flat";
                vectorCacheMaxObjects?: number;
            };
            hnsw?: {
                cleanupIntervalSeconds?: number;
                distance?: VectorDistance;
                dynamicEfFactor?: number;
                dynamicEfMax?: number;
                dynamicEfMin?: number;
                ef?: number;
                efConstruction?: number;
                filterStrategy?: VectorIndexFilterStrategy;
                flatSearchCutoff?: number;
                maxConnections?: number;
                quantizer?: {
                    cache?: (...) | (...) | (...);
                    rescoreLimit?: (...) | (...);
                    type?: (...) | (...);
                } | {
                    bitCompression?: (...) | (...) | (...);
                    centroids?: (...) | (...);
                    encoder?: (...) | (...);
                    segments?: (...) | (...);
                    trainingLimit?: (...) | (...);
                    type?: (...) | (...);
                } | {
                    rescoreLimit?: (...) | (...);
                    trainingLimit?: (...) | (...);
                    type?: (...) | (...);
                };
                skip?: boolean;
                type?: "hnsw";
                vectorCacheMaxObjects?: number;
            };
            threshold?: number;
            type?: "dynamic";
        }>);
        flat: ((opts?) => ModuleConfig<"flat", undefined | {
            distance?: VectorDistance;
            quantizer?: {
                cache?: boolean;
                rescoreLimit?: number;
                type?: "bq";
            };
            type?: "flat";
            vectorCacheMaxObjects?: number;
        }>);
        hnsw: ((opts?) => ModuleConfig<"hnsw", undefined | {
            cleanupIntervalSeconds?: number;
            distance?: VectorDistance;
            dynamicEfFactor?: number;
            dynamicEfMax?: number;
            dynamicEfMin?: number;
            ef?: number;
            efConstruction?: number;
            filterStrategy?: VectorIndexFilterStrategy;
            flatSearchCutoff?: number;
            maxConnections?: number;
            quantizer?: {
                cache?: boolean;
                rescoreLimit?: number;
                type?: "bq";
            } | {
                bitCompression?: boolean;
                centroids?: number;
                encoder?: {
                    distribution?: (...) | (...);
                    type?: (...) | (...);
                };
                segments?: number;
                trainingLimit?: number;
                type?: "pq";
            } | {
                rescoreLimit?: number;
                trainingLimit?: number;
                type?: "sq";
            };
            skip?: boolean;
            type?: "hnsw";
            vectorCacheMaxObjects?: number;
        }>);
        quantizer: {
            bq: ((options?) => QuantizerRecursivePartial<BQConfig>);
            pq: ((options?) => QuantizerRecursivePartial<PQConfig>);
            sq: ((options?) => QuantizerRecursivePartial<SQConfig>);
        };
    }
    • dynamic: ((opts?) => ModuleConfig<"dynamic", undefined | {
          distance?: VectorDistance;
          flat?: {
              distance?: VectorDistance;
              quantizer?: {
                  cache?: (...) | (...) | (...);
                  rescoreLimit?: (...) | (...);
                  type?: (...) | (...);
              };
              type?: "flat";
              vectorCacheMaxObjects?: number;
          };
          hnsw?: {
              cleanupIntervalSeconds?: number;
              distance?: VectorDistance;
              dynamicEfFactor?: number;
              dynamicEfMax?: number;
              dynamicEfMin?: number;
              ef?: number;
              efConstruction?: number;
              filterStrategy?: VectorIndexFilterStrategy;
              flatSearchCutoff?: number;
              maxConnections?: number;
              quantizer?: {
                  cache?: (...) | (...) | (...);
                  rescoreLimit?: (...) | (...);
                  type?: (...) | (...);
              } | {
                  bitCompression?: (...) | (...) | (...);
                  centroids?: (...) | (...);
                  encoder?: (...) | (...);
                  segments?: (...) | (...);
                  trainingLimit?: (...) | (...);
                  type?: (...) | (...);
              } | {
                  rescoreLimit?: (...) | (...);
                  trainingLimit?: (...) | (...);
                  type?: (...) | (...);
              };
              skip?: boolean;
              type?: "hnsw";
              vectorCacheMaxObjects?: number;
          };
          threshold?: number;
          type?: "dynamic";
      }>)

      Create a ModuleConfig<'dynamic', VectorIndexConfigDynamicCreate | undefined> object when defining the configuration of the dynamic vector index.

      Use this method when defining the options.vectorIndexConfig argument of the configure.vectorizer method.

      Returns

      The configuration object.

        • (opts?): ModuleConfig<"dynamic", undefined | {
              distance?: VectorDistance;
              flat?: {
                  distance?: VectorDistance;
                  quantizer?: {
                      cache?: (...) | (...) | (...);
                      rescoreLimit?: (...) | (...);
                      type?: (...) | (...);
                  };
                  type?: "flat";
                  vectorCacheMaxObjects?: number;
              };
              hnsw?: {
                  cleanupIntervalSeconds?: number;
                  distance?: VectorDistance;
                  dynamicEfFactor?: number;
                  dynamicEfMax?: number;
                  dynamicEfMin?: number;
                  ef?: number;
                  efConstruction?: number;
                  filterStrategy?: VectorIndexFilterStrategy;
                  flatSearchCutoff?: number;
                  maxConnections?: number;
                  quantizer?: {
                      cache?: (...) | (...) | (...);
                      rescoreLimit?: (...) | (...);
                      type?: (...) | (...);
                  } | {
                      bitCompression?: (...) | (...) | (...);
                      centroids?: (...) | (...);
                      encoder?: (...) | (...);
                      segments?: (...) | (...);
                      trainingLimit?: (...) | (...);
                      type?: (...) | (...);
                  } | {
                      rescoreLimit?: (...) | (...);
                      trainingLimit?: (...) | (...);
                      type?: (...) | (...);
                  };
                  skip?: boolean;
                  type?: "hnsw";
                  vectorCacheMaxObjects?: number;
              };
              threshold?: number;
              type?: "dynamic";
          }>

        • Parameters

          Returns ModuleConfig<"dynamic", undefined | {
              distance?: VectorDistance;
              flat?: {
                  distance?: VectorDistance;
                  quantizer?: {
                      cache?: (...) | (...) | (...);
                      rescoreLimit?: (...) | (...);
                      type?: (...) | (...);
                  };
                  type?: "flat";
                  vectorCacheMaxObjects?: number;
              };
              hnsw?: {
                  cleanupIntervalSeconds?: number;
                  distance?: VectorDistance;
                  dynamicEfFactor?: number;
                  dynamicEfMax?: number;
                  dynamicEfMin?: number;
                  ef?: number;
                  efConstruction?: number;
                  filterStrategy?: VectorIndexFilterStrategy;
                  flatSearchCutoff?: number;
                  maxConnections?: number;
                  quantizer?: {
                      cache?: (...) | (...) | (...);
                      rescoreLimit?: (...) | (...);
                      type?: (...) | (...);
                  } | {
                      bitCompression?: (...) | (...) | (...);
                      centroids?: (...) | (...);
                      encoder?: (...) | (...);
                      segments?: (...) | (...);
                      trainingLimit?: (...) | (...);
                      type?: (...) | (...);
                  } | {
                      rescoreLimit?: (...) | (...);
                      trainingLimit?: (...) | (...);
                      type?: (...) | (...);
                  };
                  skip?: boolean;
                  type?: "hnsw";
                  vectorCacheMaxObjects?: number;
              };
              threshold?: number;
              type?: "dynamic";
          }>

    • flat: ((opts?) => ModuleConfig<"flat", undefined | {
          distance?: VectorDistance;
          quantizer?: {
              cache?: boolean;
              rescoreLimit?: number;
              type?: "bq";
          };
          type?: "flat";
          vectorCacheMaxObjects?: number;
      }>)

      Create a ModuleConfig<'flat', VectorIndexConfigFlatCreate | undefined> object when defining the configuration of the FLAT vector index.

      Use this method when defining the options.vectorIndexConfig argument of the configure.vectorizer method.

      Returns

      The configuration object.

        • (opts?): ModuleConfig<"flat", undefined | {
              distance?: VectorDistance;
              quantizer?: {
                  cache?: boolean;
                  rescoreLimit?: number;
                  type?: "bq";
              };
              type?: "flat";
              vectorCacheMaxObjects?: number;
          }>

        • Parameters

          Returns ModuleConfig<"flat", undefined | {
              distance?: VectorDistance;
              quantizer?: {
                  cache?: boolean;
                  rescoreLimit?: number;
                  type?: "bq";
              };
              type?: "flat";
              vectorCacheMaxObjects?: number;
          }>

    • hnsw: ((opts?) => ModuleConfig<"hnsw", undefined | {
          cleanupIntervalSeconds?: number;
          distance?: VectorDistance;
          dynamicEfFactor?: number;
          dynamicEfMax?: number;
          dynamicEfMin?: number;
          ef?: number;
          efConstruction?: number;
          filterStrategy?: VectorIndexFilterStrategy;
          flatSearchCutoff?: number;
          maxConnections?: number;
          quantizer?: {
              cache?: boolean;
              rescoreLimit?: number;
              type?: "bq";
          } | {
              bitCompression?: boolean;
              centroids?: number;
              encoder?: {
                  distribution?: (...) | (...);
                  type?: (...) | (...);
              };
              segments?: number;
              trainingLimit?: number;
              type?: "pq";
          } | {
              rescoreLimit?: number;
              trainingLimit?: number;
              type?: "sq";
          };
          skip?: boolean;
          type?: "hnsw";
          vectorCacheMaxObjects?: number;
      }>)

      Create a ModuleConfig<'hnsw', VectorIndexConfigHNSWCreate | undefined> object when defining the configuration of the HNSW vector index.

      Use this method when defining the options.vectorIndexConfig argument of the configure.vectorizer method.

      Returns

      The configuration object.

        • (opts?): ModuleConfig<"hnsw", undefined | {
              cleanupIntervalSeconds?: number;
              distance?: VectorDistance;
              dynamicEfFactor?: number;
              dynamicEfMax?: number;
              dynamicEfMin?: number;
              ef?: number;
              efConstruction?: number;
              filterStrategy?: VectorIndexFilterStrategy;
              flatSearchCutoff?: number;
              maxConnections?: number;
              quantizer?: {
                  cache?: boolean;
                  rescoreLimit?: number;
                  type?: "bq";
              } | {
                  bitCompression?: boolean;
                  centroids?: number;
                  encoder?: {
                      distribution?: (...) | (...);
                      type?: (...) | (...);
                  };
                  segments?: number;
                  trainingLimit?: number;
                  type?: "pq";
              } | {
                  rescoreLimit?: number;
                  trainingLimit?: number;
                  type?: "sq";
              };
              skip?: boolean;
              type?: "hnsw";
              vectorCacheMaxObjects?: number;
          }>

        • Parameters

          Returns ModuleConfig<"hnsw", undefined | {
              cleanupIntervalSeconds?: number;
              distance?: VectorDistance;
              dynamicEfFactor?: number;
              dynamicEfMax?: number;
              dynamicEfMin?: number;
              ef?: number;
              efConstruction?: number;
              filterStrategy?: VectorIndexFilterStrategy;
              flatSearchCutoff?: number;
              maxConnections?: number;
              quantizer?: {
                  cache?: boolean;
                  rescoreLimit?: number;
                  type?: "bq";
              } | {
                  bitCompression?: boolean;
                  centroids?: number;
                  encoder?: {
                      distribution?: (...) | (...);
                      type?: (...) | (...);
                  };
                  segments?: number;
                  trainingLimit?: number;
                  type?: "pq";
              } | {
                  rescoreLimit?: number;
                  trainingLimit?: number;
                  type?: "sq";
              };
              skip?: boolean;
              type?: "hnsw";
              vectorCacheMaxObjects?: number;
          }>

    • quantizer: {
          bq: ((options?) => QuantizerRecursivePartial<BQConfig>);
          pq: ((options?) => QuantizerRecursivePartial<PQConfig>);
          sq: ((options?) => QuantizerRecursivePartial<SQConfig>);
      }

      Define the quantizer configuration to use when creating a vector index.

  • vectorizer: {
        img2VecNeural: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "img2vec-neural">);
        multi2VecBind: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-bind">);
        multi2VecClip: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-clip">);
        multi2VecCohere: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-cohere">);
        multi2VecGoogle: (<N, I>(opts) => VectorConfigCreate<never, N, I, "multi2vec-google">);
        multi2VecJinaAI: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-jinaai">);
        multi2VecPalm: (<N, I>(opts) => VectorConfigCreate<never, N, I, "multi2vec-palm">);
        multi2VecVoyageAI: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "multi2vec-voyageai">);
        none: (<N, I>(opts?) => VectorConfigCreate<never, N, I, "none">);
        ref2VecCentroid: (<N, I>(opts) => VectorConfigCreate<never, N, I, "ref2vec-centroid">);
        text2VecAWS: (<T, N, I>(opts) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-aws">);
        text2VecAzureOpenAI: (<T, N, I>(opts) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-azure-openai">);
        text2VecCohere: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-cohere">);
        text2VecContextionary: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-contextionary">);
        text2VecDatabricks: (<T, N, I>(opts) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-databricks">);
        text2VecGPT4All: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-gpt4all">);
        text2VecGoogle: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-google">);
        text2VecHuggingFace: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-huggingface">);
        text2VecJinaAI: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-jinaai">);
        text2VecMistral: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-mistral">);
        text2VecOllama: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-ollama">);
        text2VecOpenAI: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-openai">);
        text2VecPalm: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-palm">);
        text2VecTransformers: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-transformers">);
        text2VecVoyageAI: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-voyageai">);
        text2VecWeaviate: (<T, N, I>(opts?) => VectorConfigCreate<PrimitiveKeys<T>, N, I, "text2vec-weaviate">);
    }

Settings

Member Visibility

Theme