Fix BC for queries, add generative support, at hybrid support, use latest preview image

Author: tsmith023

.github/workflows/main.yaml

@@ -9,7 +9,7 @@ on:
 env:
   WEAVIATE_124: 1.24.19
   WEAVIATE_125: 1.25.5
-  WEAVIATE_126: preview--4e2eb3a
+  WEAVIATE_126: preview--c2bfc40
 
 jobs:
   checks:

src/collections/generate/index.ts

@@ -76,6 +76,12 @@ class GenerateManager<T> implements Generate<T> {
     if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message(query));
   };
 
+  private checkSupportForHybridNearTextAndNearVectorSubSearches = async (opts?: HybridOptions<T>) => {
+    if (opts?.vector === undefined || Array.isArray(opts.vector)) return;
+    const check = await this.dbVersionSupport.supportsHybridNearTextAndNearVectorSubsearchQueries();
+    if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message);
+  };
+
   private checkSupportForMultiTargetVectorSearch = async (opts?: BaseNearOptions<T>) => {
     if (!Serialize.isMultiTargetVector(opts)) return false;
     const check = await this.dbVersionSupport.supportsMultiTargetVectorSearch();
@@ -94,6 +100,19 @@ class GenerateManager<T> implements Generate<T> {
     };
   };
 
+  private hybridSearch = async (opts?: BaseHybridOptions<T>) => {
+    const [supportsTargets] = await Promise.all([
+      this.checkSupportForMultiTargetVectorSearch(opts),
+      this.checkSupportForNamedVectors(opts),
+      this.checkSupportForBm25AndHybridGroupByQueries('Hybrid', opts),
+      this.checkSupportForHybridNearTextAndNearVectorSubSearches(opts),
+    ]);
+    return {
+      search: await this.connection.search(this.name, this.consistencyLevel, this.tenant),
+      supportsTargets,
+    };
+  };
+
   private async parseReply(reply: SearchReply) {
     const deserialize = await Deserialize.use(this.dbVersionSupport);
     return deserialize.generate<T>(reply);
@@ -161,14 +180,10 @@ class GenerateManager<T> implements Generate<T> {
     opts: GroupByHybridOptions<T>
   ): Promise<GenerativeGroupByReturn<T>>;
   public hybrid(query: string, generate: GenerateOptions<T>, opts?: HybridOptions<T>): GenerateReturn<T> {
-    return Promise.all([
-      this.checkSupportForNamedVectors(opts),
-      this.checkSupportForBm25AndHybridGroupByQueries('Bm25', opts),
-    ])
-      .then(() => this.connection.search(this.name, this.consistencyLevel, this.tenant))
-      .then((search) =>
+    return this.hybridSearch(opts)
+      .then(({ search, supportsTargets }) =>
         search.withHybrid({
-          ...Serialize.hybrid({ query, supportsTargets: false, ...opts }),
+          ...Serialize.hybrid({ query, supportsTargets, ...opts }),
           generative: Serialize.generative(generate),
           groupBy: Serialize.isGroupBy<GroupByHybridOptions<T>>(opts)
             ? Serialize.groupBy(opts.groupBy)

src/collections/generate/integration.test.ts

@@ -7,6 +7,15 @@ import { GenerateOptions, GroupByOptions } from '../types/index.js';
 
 const maybe = process.env.OPENAI_APIKEY ? describe : describe.skip;
 
+const makeOpenAIClient = () =>
+  weaviate.connectToLocal({
+    port: 8086,
+    grpcPort: 50057,
+    headers: {
+      'X-Openai-Api-Key': process.env.OPENAI_APIKEY!,
+    },
+  });
+
 maybe('Testing of the collection.generate methods with a simple collection', () => {
   let client: WeaviateClient;
   let collection: Collection<TestCollectionGenerateSimple, 'TestCollectionGenerateSimple'>;
@@ -32,13 +41,7 @@ maybe('Testing of the collection.generate methods with a simple collection', ()
   });
 
   beforeAll(async () => {
-    client = await weaviate.connectToLocal({
-      port: 8086,
-      grpcPort: 50057,
-      headers: {
-        'X-Openai-Api-Key': process.env.OPENAI_APIKEY!,
-      },
-    });
+    client = await makeOpenAIClient();
     collection = client.collections.get(collectionName);
     id = await client.collections
       .create({
@@ -179,13 +182,7 @@ maybe('Testing of the groupBy collection.generate methods with a simple collecti
   });
 
   beforeAll(async () => {
-    client = await weaviate.connectToLocal({
-      port: 8086,
-      grpcPort: 50057,
-      headers: {
-        'X-Openai-Api-Key': process.env.OPENAI_APIKEY!,
-      },
-    });
+    client = await makeOpenAIClient();
     collection = client.collections.get(collectionName);
     id = await client.collections
       .create({
@@ -314,3 +311,116 @@ maybe('Testing of the groupBy collection.generate methods with a simple collecti
     expect(ret.objects[0].belongsToGroup).toEqual('test');
   });
 });
+
+maybe('Testing of the collection.generate methods with a multi vector collection', () => {
+  let client: WeaviateClient;
+  let collection: Collection;
+  const collectionName = 'TestCollectionQueryWithMultiVector';
+
+  let id1: string;
+  let id2: string;
+  let titleVector: number[];
+  let title2Vector: number[];
+
+  afterAll(() => {
+    return client.collections.delete(collectionName).catch((err) => {
+      console.error(err);
+      throw err;
+    });
+  });
+
+  beforeAll(async () => {
+    client = await makeOpenAIClient();
+    collection = client.collections.get(collectionName);
+    const query = () =>
+      client.collections
+        .create({
+          name: collectionName,
+          properties: [
+            {
+              name: 'title',
+              dataType: 'text',
+              vectorizePropertyName: false,
+            },
+          ],
+          vectorizers: [
+            weaviate.configure.vectorizer.text2VecOpenAI({
+              name: 'title',
+              sourceProperties: ['title'],
+            }),
+            weaviate.configure.vectorizer.text2VecOpenAI({
+              name: 'title2',
+              sourceProperties: ['title'],
+            }),
+          ],
+        })
+        .then(async () => {
+          id1 = await collection.data.insert({
+            properties: {
+              title: 'test',
+            },
+          });
+          id2 = await collection.data.insert({
+            properties: {
+              title: 'other',
+            },
+          });
+          const res = await collection.query.fetchObjectById(id1, { includeVector: true });
+          titleVector = res!.vectors.title!;
+          title2Vector = res!.vectors.title2!;
+        });
+    if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) {
+      await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError);
+      return;
+    }
+    return query();
+  });
+
+  it('should generate with a near vector search on multi vectors', async () => {
+    const query = () =>
+      collection.generate.nearVector(
+        [titleVector, title2Vector],
+        {
+          groupedTask: 'What is the value of title here? {title}',
+          groupedProperties: ['title'],
+          singlePrompt: 'Write a haiku about ducks for {title}',
+        },
+        {
+          targetVector: ['title', 'title2'],
+        }
+      );
+    if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) {
+      await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError);
+      return;
+    }
+    const ret = await query();
+    expect(ret.objects.length).toEqual(2);
+    expect(ret.generated).toBeDefined();
+    expect(ret.objects[0].generated).toBeDefined();
+    expect(ret.objects[1].generated).toBeDefined();
+  });
+
+  it('should generate with a near vector search on multi vectors', async () => {
+    const query = () =>
+      collection.generate.nearVector(
+        { title: titleVector, title2: title2Vector },
+        {
+          groupedTask: 'What is the value of title here? {title}',
+          groupedProperties: ['title'],
+          singlePrompt: 'Write a haiku about ducks for {title}',
+        },
+        {
+          targetVector: ['title', 'title2'],
+        }
+      );
+    if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) {
+      await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError);
+      return;
+    }
+    const ret = await query();
+    expect(ret.objects.length).toEqual(2);
+    expect(ret.generated).toBeDefined();
+    expect(ret.objects[0].generated).toBeDefined();
+    expect(ret.objects[1].generated).toBeDefined();
+  });
+});

src/collections/generate/types.ts

@@ -13,6 +13,7 @@ import {
   NearMediaType,
   NearOptions,
   NearTextOptions,
+  NearVectorInputType,
 } from '../query/types.js';
 import {
   GenerateOptions,
@@ -301,13 +302,13 @@ interface NearVector<T> {
    *
    * This overload is for performing a search without the `groupBy` param.
    *
-   * @param {number[]} vector - The vector to search for.
+   * @param {NearVectorInputType} vector - The vector(s) to search for.
    * @param {GenerateOptions<T>} generate - The available options for performing the generation.
    * @param {BaseNearOptions<T>} [opts] - The available options for performing the near-vector search.
    * @return {Promise<GenerativeReturn<T>>} - The results of the search including the generated data.
    */
   nearVector(
-    vector: number[],
+    vector: NearVectorInputType,
     generate: GenerateOptions<T>,
     opts?: BaseNearOptions<T>
   ): Promise<GenerativeReturn<T>>;
@@ -318,13 +319,13 @@ interface NearVector<T> {
    *
    * This overload is for performing a search with the `groupBy` param.
    *
-   * @param {number[]} vector - The vector to search for.
+   * @param {NearVectorInputType} vector - The vector(s) to search for.
    * @param {GenerateOptions<T>} generate - The available options for performing the generation.
    * @param {GroupByNearOptions<T>} opts - The available options for performing the near-vector search.
    * @return {Promise<GenerativeGroupByReturn<T>>} - The results of the search including the generated data grouped by the specified properties.
    */
   nearVector(
-    vector: number[],
+    vector: NearVectorInputType,
     generate: GenerateOptions<T>,
     opts: GroupByNearOptions<T>
   ): Promise<GenerativeGroupByReturn<T>>;
@@ -335,12 +336,16 @@ interface NearVector<T> {
    *
    * This overload is for performing a search with a programmatically defined `opts` param.
    *
-   * @param {number[]} vector - The vector to search for.
+   * @param {NearVectorInputType} vector - The vector(s) to search for.
    * @param {GenerateOptions<T>} generate - The available options for performing the generation.
    * @param {NearOptions<T>} [opts] - The available options for performing the near-vector search.
    * @return {GenerateReturn<T>} - The results of the search including the generated data.
    */
-  nearVector(vector: number[], generate: GenerateOptions<T>, opts?: NearOptions<T>): GenerateReturn<T>;
+  nearVector(
+    vector: NearVectorInputType,
+    generate: GenerateOptions<T>,
+    opts?: NearOptions<T>
+  ): GenerateReturn<T>;
 }
 
 export interface Generate<T>

src/collections/query/index.ts

@@ -93,9 +93,22 @@ class QueryManager<T> implements Query<T> {
   };
 
   private nearSearch = async (opts?: BaseNearOptions<T>) => {
-    const [_, supportsTargets] = await Promise.all([
+    const [supportsTargets] = await Promise.all([
+      this.checkSupportForMultiTargetVectorSearch(opts),
       this.checkSupportForNamedVectors(opts),
+    ]);
+    return {
+      search: await this.connection.search(this.name, this.consistencyLevel, this.tenant),
+      supportsTargets,
+    };
+  };
+
+  private hybridSearch = async (opts?: BaseHybridOptions<T>) => {
+    const [supportsTargets] = await Promise.all([
       this.checkSupportForMultiTargetVectorSearch(opts),
+      this.checkSupportForNamedVectors(opts),
+      this.checkSupportForBm25AndHybridGroupByQueries('Hybrid', opts),
+      this.checkSupportForHybridNearTextAndNearVectorSubSearches(opts),
     ]);
     return {
       search: await this.connection.search(this.name, this.consistencyLevel, this.tenant),
@@ -153,15 +166,10 @@ class QueryManager<T> implements Query<T> {
   public hybrid(query: string, opts?: BaseHybridOptions<T>): Promise<WeaviateReturn<T>>;
   public hybrid(query: string, opts: GroupByHybridOptions<T>): Promise<GroupByReturn<T>>;
   public hybrid(query: string, opts?: HybridOptions<T>): QueryReturn<T> {
-    return Promise.all([
-      this.checkSupportForNamedVectors(opts),
-      this.checkSupportForBm25AndHybridGroupByQueries('Hybrid', opts),
-      this.checkSupportForHybridNearTextAndNearVectorSubSearches(opts),
-    ])
-      .then(() => this.connection.search(this.name, this.consistencyLevel, this.tenant))
-      .then((search) =>
+    return this.hybridSearch(opts)
+      .then(({ search, supportsTargets }) =>
         search.withHybrid({
-          ...Serialize.hybrid({ query, supportsTargets: false, ...opts }),
+          ...Serialize.hybrid({ query, supportsTargets, ...opts }),
           groupBy: Serialize.isGroupBy<GroupByHybridOptions<T>>(opts)
             ? Serialize.groupBy(opts.groupBy)
             : undefined,