Making sweeping changes:

- Introduce `V` generic for collections allowing users to define types for their multiple vectors
- Add support for creating multivector collections
- Add BC support for querying multivector collections
- Add yielding to de/ser logic of multivectors to avoid expensive blocking CPU loops
- Update CI image

Author: tsmith023

.github/workflows/main.yaml

@@ -12,7 +12,7 @@ env:
   WEAVIATE_126: 1.26.14
   WEAVIATE_127: 1.27.11
   WEAVIATE_128: 1.28.4
-  WEAVIATE_129: 1.29.0-rc.0
+  WEAVIATE_129: 1.29.0-rc.1
 
 jobs:
   checks:

package.json

@@ -101,7 +101,8 @@
     "*.{ts,js}": [
       "npm run format:check",
       "npm run lint -- --cache",
-      "npm run prepack"
+      "npm run prepack",
+      "npm run docs"
     ]
   }
 }

src/collections/aggregate/index.ts

@@ -9,7 +9,7 @@ import { WeaviateInvalidInputError, WeaviateQueryError } from '../../errors.js';
 import { Aggregator } from '../../graphql/index.js';
 import { PrimitiveKeys, toBase64FromMedia } from '../../index.js';
 import { Deserialize } from '../deserialize/index.js';
-import { Bm25QueryProperty, NearVectorInputType } from '../query/types.js';
+import { Bm25QueryProperty, NearVectorInputType, TargetVector } from '../query/types.js';
 import { NearVectorInputGuards } from '../query/utils.js';
 import { Serialize } from '../serialize/index.js';
 
@@ -31,27 +31,27 @@ export type GroupByAggregate<T> = {
 
 export type AggregateOverAllOptions<M> = AggregateBaseOptions<M>;
 
-export type AggregateNearOptions<M> = AggregateBaseOptions<M> & {
+export type AggregateNearOptions<M, V> = AggregateBaseOptions<M> & {
   certainty?: number;
   distance?: number;
   objectLimit?: number;
-  targetVector?: string;
+  targetVector?: TargetVector<V>;
 };
 
-export type AggregateHybridOptions<T, M> = AggregateBaseOptions<M> & {
+export type AggregateHybridOptions<T, M, V> = AggregateBaseOptions<M> & {
   alpha?: number;
   maxVectorDistance?: number;
   objectLimit?: number;
   queryProperties?: (PrimitiveKeys<T> | Bm25QueryProperty<T>)[];
-  targetVector?: string;
+  targetVector?: TargetVector<V>;
   vector?: number[];
 };
 
-export type AggregateGroupByHybridOptions<T, M> = AggregateHybridOptions<T, M> & {
+export type AggregateGroupByHybridOptions<T, M, V> = AggregateHybridOptions<T, M, V> & {
   groupBy: PropertyOf<T> | GroupByAggregate<T>;
 };
 
-export type AggregateGroupByNearOptions<T, M> = AggregateNearOptions<M> & {
+export type AggregateGroupByNearOptions<T, M, V> = AggregateNearOptions<M, V> & {
   groupBy: PropertyOf<T> | GroupByAggregate<T>;
 };
 
@@ -346,9 +346,9 @@ export type AggregateGroupByResult<
   };
 };
 
-class AggregateManager<T> implements Aggregate<T> {
+class AggregateManager<T, V> implements Aggregate<T, V> {
   connection: Connection;
-  groupBy: AggregateGroupBy<T>;
+  groupBy: AggregateGroupBy<T, V>;
   name: string;
   dbVersionSupport: DbVersionSupport;
   consistencyLevel?: ConsistencyLevel;
@@ -373,7 +373,7 @@ class AggregateManager<T> implements Aggregate<T> {
     this.groupBy = {
       hybrid: async <M extends PropertiesMetrics<T>>(
         query: string,
-        opts: AggregateGroupByHybridOptions<T, M>
+        opts: AggregateGroupByHybridOptions<T, M, V>
       ): Promise<AggregateGroupByResult<T, M>[]> => {
         if (await this.grpcChecker) {
           const group = typeof opts.groupBy === 'string' ? { property: opts.groupBy } : opts.groupBy;
@@ -402,7 +402,7 @@ class AggregateManager<T> implements Aggregate<T> {
       },
       nearImage: async <M extends PropertiesMetrics<T>>(
         image: string | Buffer,
-        opts: AggregateGroupByNearOptions<T, M>
+        opts: AggregateGroupByNearOptions<T, M, V>
       ): Promise<AggregateGroupByResult<T, M>[]> => {
         const [b64, usesGrpc] = await Promise.all([await toBase64FromMedia(image), await this.grpcChecker]);
         if (usesGrpc) {
@@ -430,7 +430,7 @@ class AggregateManager<T> implements Aggregate<T> {
       },
       nearObject: async <M extends PropertiesMetrics<T>>(
         id: string,
-        opts: AggregateGroupByNearOptions<T, M>
+        opts: AggregateGroupByNearOptions<T, M, V>
       ): Promise<AggregateGroupByResult<T, M>[]> => {
         if (await this.grpcChecker) {
           const group = typeof opts.groupBy === 'string' ? { property: opts.groupBy } : opts.groupBy;
@@ -457,7 +457,7 @@ class AggregateManager<T> implements Aggregate<T> {
       },
       nearText: async <M extends PropertiesMetrics<T>>(
         query: string | string[],
-        opts: AggregateGroupByNearOptions<T, M>
+        opts: AggregateGroupByNearOptions<T, M, V>
       ): Promise<AggregateGroupByResult<T, M>[]> => {
         if (await this.grpcChecker) {
           const group = typeof opts.groupBy === 'string' ? { property: opts.groupBy } : opts.groupBy;
@@ -484,7 +484,7 @@ class AggregateManager<T> implements Aggregate<T> {
       },
       nearVector: async <M extends PropertiesMetrics<T>>(
         vector: number[],
-        opts: AggregateGroupByNearOptions<T, M>
+        opts: AggregateGroupByNearOptions<T, M, V>
       ): Promise<AggregateGroupByResult<T, M>[]> => {
         if (await this.grpcChecker) {
           const group = typeof opts.groupBy === 'string' ? { property: opts.groupBy } : opts.groupBy;
@@ -593,19 +593,19 @@ class AggregateManager<T> implements Aggregate<T> {
     return `${propertyName} { ${body} }`;
   }
 
-  static use<T>(
+  static use<T, V>(
     connection: Connection,
     name: string,
     dbVersionSupport: DbVersionSupport,
     consistencyLevel?: ConsistencyLevel,
     tenant?: string
-  ): AggregateManager<T> {
-    return new AggregateManager<T>(connection, name, dbVersionSupport, consistencyLevel, tenant);
+  ): AggregateManager<T, V> {
+    return new AggregateManager<T, V>(connection, name, dbVersionSupport, consistencyLevel, tenant);
   }
 
   async hybrid<M extends PropertiesMetrics<T>>(
     query: string,
-    opts?: AggregateHybridOptions<T, M>
+    opts?: AggregateHybridOptions<T, M, V>
   ): Promise<AggregateResult<T, M>> {
     if (await this.grpcChecker) {
       return this.grpc()
@@ -628,7 +628,7 @@ class AggregateManager<T> implements Aggregate<T> {
 
   async nearImage<M extends PropertiesMetrics<T>>(
     image: string | Buffer,
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>> {
     const [b64, usesGrpc] = await Promise.all([await toBase64FromMedia(image), await this.grpcChecker]);
     if (usesGrpc) {
@@ -650,7 +650,7 @@ class AggregateManager<T> implements Aggregate<T> {
 
   async nearObject<M extends PropertiesMetrics<T>>(
     id: string,
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>> {
     if (await this.grpcChecker) {
       return this.grpc()
@@ -671,7 +671,7 @@ class AggregateManager<T> implements Aggregate<T> {
 
   async nearText<M extends PropertiesMetrics<T>>(
     query: string | string[],
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>> {
     if (await this.grpcChecker) {
       return this.grpc()
@@ -692,7 +692,7 @@ class AggregateManager<T> implements Aggregate<T> {
 
   async nearVector<M extends PropertiesMetrics<T>>(
     vector: NearVectorInputType,
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>> {
     if (await this.grpcChecker) {
       return this.grpc()
@@ -770,9 +770,9 @@ class AggregateManager<T> implements Aggregate<T> {
   };
 }
 
-export interface Aggregate<T> {
+export interface Aggregate<T, V> {
   /** This namespace contains methods perform a group by search while aggregating metrics. */
-  groupBy: AggregateGroupBy<T>;
+  groupBy: AggregateGroupBy<T, V>;
   /**
    * Aggregate metrics over the objects returned by a hybrid search on this collection.
    *
@@ -784,7 +784,7 @@ export interface Aggregate<T> {
    */
   hybrid<M extends PropertiesMetrics<T>>(
     query: string,
-    opts?: AggregateHybridOptions<T, M>
+    opts?: AggregateHybridOptions<T, M, V>
   ): Promise<AggregateResult<T, M>>;
   /**
    * Aggregate metrics over the objects returned by a near image vector search on this collection.
@@ -799,7 +799,7 @@ export interface Aggregate<T> {
    */
   nearImage<M extends PropertiesMetrics<T>>(
     image: string | Buffer,
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>>;
   /**
    * Aggregate metrics over the objects returned by a near object search on this collection.
@@ -814,7 +814,7 @@ export interface Aggregate<T> {
    */
   nearObject<M extends PropertiesMetrics<T>>(
     id: string,
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>>;
   /**
    * Aggregate metrics over the objects returned by a near vector search on this collection.
@@ -829,7 +829,7 @@ export interface Aggregate<T> {
    */
   nearText<M extends PropertiesMetrics<T>>(
     query: string | string[],
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>>;
   /**
    * Aggregate metrics over the objects returned by a near vector search on this collection.
@@ -844,7 +844,7 @@ export interface Aggregate<T> {
    */
   nearVector<M extends PropertiesMetrics<T>>(
     vector: number[],
-    opts?: AggregateNearOptions<M>
+    opts?: AggregateNearOptions<M, V>
   ): Promise<AggregateResult<T, M>>;
   /**
    * Aggregate metrics over all the objects in this collection without any vector search.
@@ -855,7 +855,7 @@ export interface Aggregate<T> {
   overAll<M extends PropertiesMetrics<T>>(opts?: AggregateOverAllOptions<M>): Promise<AggregateResult<T, M>>;
 }
 
-export interface AggregateGroupBy<T> {
+export interface AggregateGroupBy<T, V> {
   /**
    * Aggregate metrics over the objects grouped by a specified property and returned by a hybrid search on this collection.
    *
@@ -867,7 +867,7 @@ export interface AggregateGroupBy<T> {
    */
   hybrid<M extends PropertiesMetrics<T>>(
     query: string,
-    opts: AggregateGroupByHybridOptions<T, M>
+    opts: AggregateGroupByHybridOptions<T, M, V>
   ): Promise<AggregateGroupByResult<T, M>[]>;
   /**
    * Aggregate metrics over the objects grouped by a specified property and returned by a near image vector search on this collection.
@@ -882,7 +882,7 @@ export interface AggregateGroupBy<T> {
    */
   nearImage<M extends PropertiesMetrics<T>>(
     image: string | Buffer,
-    opts: AggregateGroupByNearOptions<T, M>
+    opts: AggregateGroupByNearOptions<T, M, V>
   ): Promise<AggregateGroupByResult<T, M>[]>;
   /**
    * Aggregate metrics over the objects grouped by a specified property and returned by a near object search on this collection.
@@ -897,7 +897,7 @@ export interface AggregateGroupBy<T> {
    */
   nearObject<M extends PropertiesMetrics<T>>(
     id: string,
-    opts: AggregateGroupByNearOptions<T, M>
+    opts: AggregateGroupByNearOptions<T, M, V>
   ): Promise<AggregateGroupByResult<T, M>[]>;
   /**
    * Aggregate metrics over the objects grouped by a specified property and returned by a near text vector search on this collection.
@@ -912,7 +912,7 @@ export interface AggregateGroupBy<T> {
    */
   nearText<M extends PropertiesMetrics<T>>(
     query: string | string[],
-    opts: AggregateGroupByNearOptions<T, M>
+    opts: AggregateGroupByNearOptions<T, M, V>
   ): Promise<AggregateGroupByResult<T, M>[]>;
   /**
    * Aggregate metrics over the objects grouped by a specified property and returned by a near vector search on this collection.
@@ -927,7 +927,7 @@ export interface AggregateGroupBy<T> {
    */
   nearVector<M extends PropertiesMetrics<T>>(
     vector: number[],
-    opts: AggregateGroupByNearOptions<T, M>
+    opts: AggregateGroupByNearOptions<T, M, V>
   ): Promise<AggregateGroupByResult<T, M>[]>;
   /**
    * Aggregate metrics over all the objects in this collection grouped by a specified property without any vector search.

src/collections/aggregate/integration.test.ts

@@ -485,7 +485,7 @@ describe('Testing of collection.aggregate search methods', () => {
 
   it('should return an aggregation on a nearVector search', async () => {
     const obj = await collection.query.fetchObjectById(uuid, { includeVector: true });
-    const result = await collection.aggregate.nearVector(obj?.vectors.default!, {
+    const result = await collection.aggregate.nearVector(obj?.vectors.default as number[], {
       objectLimit: 1000,
       returnMetrics: collection.metrics.aggregate('text').text(['count']),
     });
@@ -494,7 +494,7 @@ describe('Testing of collection.aggregate search methods', () => {
 
   it('should return a grouped aggregation on a nearVector search', async () => {
     const obj = await collection.query.fetchObjectById(uuid, { includeVector: true });
-    const result = await collection.aggregate.groupBy.nearVector(obj?.vectors.default!, {
+    const result = await collection.aggregate.groupBy.nearVector(obj?.vectors.default as number[], {
       objectLimit: 1000,
       groupBy: 'text',
       returnMetrics: collection.metrics.aggregate('text').text(['count']),