Add implementation supporting multi-vectors (no tests yet)

Author: tsmith023

src/collections/aggregate/index.ts

@@ -378,9 +378,9 @@ class AggregateManager<T> implements Aggregate<T> {
         if (await this.grpcChecker) {
           const group = typeof opts.groupBy === 'string' ? { property: opts.groupBy } : opts.groupBy;
           return this.grpc()
-            .then((aggregate) =>
+            .then(async (aggregate) =>
               aggregate.withHybrid({
-                ...Serialize.aggregate.hybrid(query, opts),
+                ...(await Serialize.aggregate.hybrid(query, opts)),
                 groupBy: Serialize.aggregate.groupBy(group),
                 limit: group.limit,
               })
@@ -489,9 +489,9 @@ class AggregateManager<T> implements Aggregate<T> {
         if (await this.grpcChecker) {
           const group = typeof opts.groupBy === 'string' ? { property: opts.groupBy } : opts.groupBy;
           return this.grpc()
-            .then((aggregate) =>
+            .then(async (aggregate) =>
               aggregate.withNearVector({
-                ...Serialize.aggregate.nearVector(vector, opts),
+                ...(await Serialize.aggregate.nearVector(vector, opts)),
                 groupBy: Serialize.aggregate.groupBy(group),
                 limit: group.limit,
               })
@@ -609,7 +609,7 @@ class AggregateManager<T> implements Aggregate<T> {
   ): Promise<AggregateResult<T, M>> {
     if (await this.grpcChecker) {
       return this.grpc()
-        .then((aggregate) => aggregate.withHybrid(Serialize.aggregate.hybrid(query, opts)))
+        .then(async (aggregate) => aggregate.withHybrid(await Serialize.aggregate.hybrid(query, opts)))
         .then((reply) => Deserialize.aggregate(reply));
     }
     let builder = this.base(opts?.returnMetrics, opts?.filters).withHybrid({
@@ -696,10 +696,12 @@ class AggregateManager<T> implements Aggregate<T> {
   ): Promise<AggregateResult<T, M>> {
     if (await this.grpcChecker) {
       return this.grpc()
-        .then((aggregate) => aggregate.withNearVector(Serialize.aggregate.nearVector(vector, opts)))
+        .then(async (aggregate) =>
+          aggregate.withNearVector(await Serialize.aggregate.nearVector(vector, opts))
+        )
         .then((reply) => Deserialize.aggregate(reply));
     }
-    if (!NearVectorInputGuards.is1DArray(vector)) {
+    if (!NearVectorInputGuards.is1D(vector)) {
       throw new WeaviateInvalidInputError(
         'Vector can only be a 1D array of numbers when using `nearVector` with <1.29 Weaviate versions.'
       );

src/collections/query/check.ts

@@ -98,6 +98,18 @@ export class Check<T> {
     return check.supports;
   };
 
+  private checkSupportForVectors = async (
+    vec?: NearVectorInputType | HybridNearVectorSubSearch | HybridNearTextSubSearch
+  ) => {
+    if (vec === undefined || Serialize.isHybridNearTextSearch(vec)) return false;
+    if (Serialize.isHybridNearVectorSearch(vec) && !Serialize.isMultiVectorPerTarget(vec.vector))
+      return false;
+    if (Serialize.isHybridVectorSearch(vec) && !Serialize.isMultiVectorPerTarget(vec)) return false;
+    const check = await this.dbVersionSupport.supportsMultiVectorPerTargetSearch();
+    if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message);
+    return check.supports;
+  };
+
   public nearSearch = (opts?: BaseNearOptions<T>) => {
     return Promise.all([
       this.getSearcher(),
@@ -118,6 +130,7 @@ export class Check<T> {
       this.checkSupportForMultiVectorSearch(vec),
       this.checkSupportForMultiVectorPerTargetSearch(vec),
       this.checkSupportForMultiWeightPerTargetSearch(opts),
+      this.checkSupportForVectors(),
       this.checkSupportForNamedVectors(opts),
     ]).then(
       ([
@@ -126,14 +139,17 @@ export class Check<T> {
         supportsMultiVector,
         supportsVectorsForTargets,
         supportsWeightsForTargets,
+        supportsVectors,
       ]) => {
         const is126 = supportsMultiTarget || supportsMultiVector;
         const is127 = supportsVectorsForTargets || supportsWeightsForTargets;
+        const is129 = supportsVectors;
         return {
           search,
           supportsTargets: is126 || is127,
           supportsVectorsForTargets: is127,
           supportsWeightsForTargets: is127,
+          supportsVectors: is129,
         };
       }
     );
@@ -146,6 +162,7 @@ export class Check<T> {
       this.checkSupportForMultiVectorSearch(opts?.vector),
       this.checkSupportForMultiVectorPerTargetSearch(opts?.vector),
       this.checkSupportForMultiWeightPerTargetSearch(opts),
+      this.checkSupportForVectors(),
       this.checkSupportForNamedVectors(opts),
       this.checkSupportForBm25AndHybridGroupByQueries('Hybrid', opts),
       this.checkSupportForHybridNearTextAndNearVectorSubSearches(opts),
@@ -156,14 +173,17 @@ export class Check<T> {
         supportsMultiVector,
         supportsWeightsForTargets,
         supportsVectorsForTargets,
+        supportsVectors,
       ]) => {
         const is126 = supportsMultiTarget || supportsMultiVector;
         const is127 = supportsVectorsForTargets || supportsWeightsForTargets;
+        const is129 = supportsVectors;
         return {
           search,
           supportsTargets: is126 || is127,
           supportsWeightsForTargets: is127,
           supportsVectorsForTargets: is127,
+          supportsVectors: is129,
         };
       }
     );

src/collections/query/factories.ts

@@ -0,0 +1,22 @@
+import { ListOfVectors, PrimitiveVectorType } from './types.js';
+import { NearVectorInputGuards } from './utils.js';
+
+const hybridVector = {
+  nearText: () => {},
+  nearVector: () => {},
+};
+
+const nearVector = {
+  listOfVectors: <V extends PrimitiveVectorType>(...vectors: V[]): ListOfVectors<V> => {
+    return {
+      kind: 'listOfVectors',
+      dimensionality: NearVectorInputGuards.is1D(vectors[0]) ? '1D' : '2D',
+      vectors,
+    };
+  },
+};
+
+export const queryFactory = {
+  hybridVector,
+  nearVector,
+};

src/collections/query/index.ts

@@ -95,14 +95,25 @@ class QueryManager<T> implements Query<T> {
   public hybrid(query: string, opts?: HybridOptions<T>): QueryReturn<T> {
     return this.check
       .hybridSearch(opts)
-      .then(({ search, supportsTargets, supportsWeightsForTargets, supportsVectorsForTargets }) =>
-        search.withHybrid(
-          Serialize.search.hybrid(
-            { query, supportsTargets, supportsWeightsForTargets, supportsVectorsForTargets },
-            opts
-          )
-        )
+      .then(
+        async ({
+          search,
+          supportsTargets,
+          supportsWeightsForTargets,
+          supportsVectorsForTargets,
+          supportsVectors,
+        }) => ({
+          search,
+          args: await Serialize.search.hybrid({
+            query,
+            supportsTargets,
+            supportsWeightsForTargets,
+            supportsVectorsForTargets,
+            supportsVectors,
+          }),
+        })
       )
+      .then(({ search, args }) => search.withHybrid(args))
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
@@ -112,19 +123,19 @@ class QueryManager<T> implements Query<T> {
     return this.check
       .nearSearch(opts)
       .then(({ search, supportsTargets, supportsWeightsForTargets }) => {
-        return toBase64FromMedia(image).then((image) =>
-          search.withNearImage(
-            Serialize.search.nearImage(
-              {
-                image,
-                supportsTargets,
-                supportsWeightsForTargets,
-              },
-              opts
-            )
-          )
-        );
+        return toBase64FromMedia(image).then((image) => ({
+          search,
+          args: Serialize.search.nearImage(
+            {
+              image,
+              supportsTargets,
+              supportsWeightsForTargets,
+            },
+            opts
+          ),
+        }));
       })
+      .then(({ search, args }) => search.withNearImage(args))
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
@@ -183,18 +194,18 @@ class QueryManager<T> implements Query<T> {
   public nearObject(id: string, opts?: NearOptions<T>): QueryReturn<T> {
     return this.check
       .nearSearch(opts)
-      .then(({ search, supportsTargets, supportsWeightsForTargets }) =>
-        search.withNearObject(
-          Serialize.search.nearObject(
-            {
-              id,
-              supportsTargets,
-              supportsWeightsForTargets,
-            },
-            opts
-          )
-        )
-      )
+      .then(({ search, supportsTargets, supportsWeightsForTargets }) => ({
+        search,
+        args: Serialize.search.nearObject(
+          {
+            id,
+            supportsTargets,
+            supportsWeightsForTargets,
+          },
+          opts
+        ),
+      }))
+      .then(({ search, args }) => search.withNearObject(args))
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
@@ -203,18 +214,18 @@ class QueryManager<T> implements Query<T> {
   public nearText(query: string | string[], opts?: NearTextOptions<T>): QueryReturn<T> {
     return this.check
       .nearSearch(opts)
-      .then(({ search, supportsTargets, supportsWeightsForTargets }) =>
-        search.withNearText(
-          Serialize.search.nearText(
-            {
-              query,
-              supportsTargets,
-              supportsWeightsForTargets,
-            },
-            opts
-          )
-        )
-      )
+      .then(({ search, supportsTargets, supportsWeightsForTargets }) => ({
+        search,
+        args: Serialize.search.nearText(
+          {
+            query,
+            supportsTargets,
+            supportsWeightsForTargets,
+          },
+          opts
+        ),
+      }))
+      .then(({ search, args }) => search.withNearText(args))
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
@@ -223,25 +234,34 @@ class QueryManager<T> implements Query<T> {
   public nearVector(vector: NearVectorInputType, opts?: NearOptions<T>): QueryReturn<T> {
     return this.check
       .nearVector(vector, opts)
-      .then(({ search, supportsTargets, supportsVectorsForTargets, supportsWeightsForTargets }) =>
-        search.withNearVector(
-          Serialize.search.nearVector(
+      .then(
+        async ({
+          search,
+          supportsTargets,
+          supportsVectorsForTargets,
+          supportsWeightsForTargets,
+          supportsVectors,
+        }) => ({
+          search,
+          args: await Serialize.search.nearVector(
             {
               vector,
               supportsTargets,
               supportsVectorsForTargets,
               supportsWeightsForTargets,
+              supportsVectors,
             },
             opts
-          )
-        )
+          ),
+        })
       )
+      .then(({ search, args }) => search.withNearVector(args))
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 }
 
 export default QueryManager.use;
-
+export { queryFactory } from './factories.js';
 export {
   BaseBm25Options,
   BaseHybridOptions,

src/collections/query/types.ts

@@ -183,12 +183,27 @@ export type GroupByNearTextOptions<T> = BaseNearTextOptions<T> & {
 /** The type of the media to search for in the `query.nearMedia` method */
 export type NearMediaType = 'audio' | 'depth' | 'image' | 'imu' | 'thermal' | 'video';
 
+/** The allowed types of primitive vectors as stored in Weaviate.
+ *
+ * These correspond to 1-dimensional vectors, created by modules named `x2vec-`, and 2-dimensional vectors, created by modules named `x2colbert-`.
+ */
+export type PrimitiveVectorType = number[] | number[][];
+
+export type ListOfVectors<V extends PrimitiveVectorType> = {
+  kind: 'listOfVectors';
+  dimensionality: '1D' | '2D';
+  vectors: V[];
+};
+
 /**
  * The vector(s) to search for in the `query/generate.nearVector` and `query/generate.hybrid` methods. One of:
- * - a single vector, in which case pass a single number array.
- * - multiple named vectors, in which case pass an object of type `Record<string, number[] | number[][]>`.
+ * - a single 1-dimensional vector, in which case pass a single number array.
+ * - a single 2-dimensional vector, in which case pas a single array of number arrays.
+ * - multiple named vectors, in which case pass an object of type `Record<string, PrimitiveVectorType>`.
  */
-export type NearVectorInputType = number[] | Record<string, number[] | number[][]>;
+export type NearVectorInputType =
+  | PrimitiveVectorType
+  | Record<string, PrimitiveVectorType | ListOfVectors<number[]> | ListOfVectors<number[][]>>;
 
 /**
  * Over which vector spaces to perform the vector search query in the `nearX` search method. One of:

src/collections/query/utils.ts

@@ -1,14 +1,34 @@
 import { MultiTargetVectorJoin } from '../index.js';
-import { NearVectorInputType, TargetVectorInputType } from './types.js';
+import { ListOfVectors, NearVectorInputType, PrimitiveVectorType, TargetVectorInputType } from './types.js';
 
 export class NearVectorInputGuards {
-  public static is1DArray(input: NearVectorInputType): input is number[] {
+  public static is1D(input: NearVectorInputType): input is number[] {
     return Array.isArray(input) && input.length > 0 && !Array.isArray(input[0]);
   }
 
-  public static isObject(input: NearVectorInputType): input is Record<string, number[] | number[][]> {
+  public static is2D(input: NearVectorInputType): input is number[][] {
+    return Array.isArray(input) && input.length > 0 && Array.isArray(input[0]) && input[0].length > 0;
+  }
+
+  public static isObject(
+    input: NearVectorInputType
+  ): input is Record<string, PrimitiveVectorType | ListOfVectors<number[]> | ListOfVectors<number[][]>> {
     return !Array.isArray(input);
   }
+
+  public static isListOf1D(
+    input: PrimitiveVectorType | ListOfVectors<number[]> | ListOfVectors<number[][]>
+  ): input is ListOfVectors<number[]> {
+    const i = input as ListOfVectors<number[]>;
+    return !Array.isArray(input) && i.kind === 'listOfVectors' && i.dimensionality == '1D';
+  }
+
+  public static isListOf2D(
+    input: PrimitiveVectorType | ListOfVectors<number[]> | ListOfVectors<number[][]>
+  ): input is ListOfVectors<number[][]> {
+    const i = input as ListOfVectors<number[][]>;
+    return !Array.isArray(input) && i.kind === 'listOfVectors' && i.dimensionality == '2D';
+  }
 }
 
 export class ArrayInputGuards {