Adds support for hybrid search

Author: donomii

ci/docker-compose.yml

@@ -2,7 +2,7 @@
 version: '3.4'
 services:
   weaviate:
-    image: semitechnologies/weaviate:preview-replace-shardingconfig-replicas-with-replication-factor-29e987d
+    image: semitechnologies/weaviate:1.17.0-prealpha-e8b5ccb
     restart: on-failure:0
     ports:
       - "8080:8080"

cluster/journey.test.js

@@ -2,7 +2,7 @@ const weaviate = require("../index");
 const { createTestFoodSchemaAndData, cleanupTestFood, PIZZA_CLASS_NAME, SOUP_CLASS_NAME } = require("../utils/testData");
 
 const EXPECTED_WEAVIATE_VERSION = "1.17.0-prealpha"
-const EXPECTED_WEAVIATE_GIT_HASH = "29e987d"
+const EXPECTED_WEAVIATE_GIT_HASH = "e8b5ccb"
 
 describe("cluster nodes endpoint", () => {
   const client = weaviate.client({

graphql/bm25.js

@@ -0,0 +1,57 @@
+export default class GraphQLBm25 {
+  constructor(bm25Obj) {
+    this.source = bm25Obj;
+  }
+
+  toString(wrap = true) {
+    this.parse();
+    this.validate();
+
+    let args = [`query:${JSON.stringify(this.query)}`]; // query must always be set
+   
+    if (this.properties) {
+      args = [...args, `properties:${JSON.stringify(this.properties)}`];
+    }
+
+    return `{${args.join(",")}}`;
+  }
+
+  validate() {
+    if (!this.query) {
+      throw new Error("bm25 filter: query cannot be empty");
+    }
+  }
+
+  parse() {
+    for (let key in this.source) {
+      switch (key) {
+        case "query":
+          this.parseQuery(this.source[key]);
+          break;
+        case "properties":
+          this.parseProperties(this.source[key]);
+          break;
+        default:
+          throw new Error("bm25 filter: unrecognized key '" + key + "'");
+      }
+    }
+  }
+
+ 
+  parseProperties(properties) {
+    if (!Array.isArray(properties)) {
+      throw new Error("bm25 filter: properties must be an array");
+    }
+
+    this.properties = properties;
+  }
+
+  parseQuery(query) {
+    if (typeof query !== "string") {
+      throw new Error("bm25 filter: query must be a number");
+    }
+
+    this.query = query;
+  }
+
+}

graphql/getter.js

@@ -1,6 +1,8 @@
 import Where from "./where";
 import NearText from "./nearText";
 import NearVector from "./nearVector";
+import Bm25 from "./bm25";
+import Hybrid from "./hybrid";
 import NearObject from "./nearObject";
 import NearImage from "./nearImage";
 import Ask from "./ask";
@@ -60,6 +62,27 @@ export default class Getter {
     return this;
   };
 
+  withBm25 = (bm25Obj) => {
+    try {
+      this.bm25String = new Bm25(bm25Obj).toString();
+    } catch (e) {
+      this.errors = [...this.errors, e];
+    }
+
+    return this;
+  };
+
+  withHybrid = (hybridObj) => {
+    try {
+      this.hybridString = new Hybrid(hybridObj).toString();
+    } catch (e) {
+      this.errors = [...this.errors, e];
+    }
+
+    return this;
+  };
+
+
   withNearObject = (nearObjectObj) => {
     if (this.includesNearMediaFilter) {
       throw new Error(

graphql/hybrid.js

@@ -0,0 +1,73 @@
+export default class GraphQLHybrid {
+  constructor(hybridObj) {
+    this.source = hybridObj;
+  }
+
+  toString(wrap = true) {
+    this.parse();
+    this.validate();
+
+    let args = [`query:${JSON.stringify(this.query)}`]; // query must always be set
+
+    if (this.alpha) {
+      args = [...args, `alpha:${JSON.stringify(this.alpha)}`];
+    }
+
+    if (this.vector) {
+      args = [...args, `vector:${JSON.stringify(this.vector)}`];
+    }
+
+    if (!wrap) {
+      return `${args.join(",")}`;
+    }
+    return `{${args.join(",")}}`;
+  }
+
+  validate() {
+    if (!this.query) {
+      throw new Error("hybrid filter: query cannot be empty");
+    }
+  }
+
+  parse() {
+    for (let key in this.source) {
+      switch (key) {
+        case "query":
+          this.parseQuery(this.source[key]);
+          break;
+        case "alpha":
+          this.parseAlpha(this.source[key]);
+          break;
+        case "vector":
+          this.parseVector(this.source[key]);
+          break;
+        default:
+          throw new Error("hybrid filter: unrecognized key '" + key + "'");
+      }
+    }
+  }
+
+  parseVector(vector) {
+    if (!Array.isArray(vector)) {
+      throw new Error("hybrid filter: vector must be an array");
+    }
+
+    this.vector = vector;
+  }
+
+  parseQuery(query) {
+    if (typeof query !== "string") {
+      throw new Error("hybrid filter: query must be a string");
+    }
+
+    this.query = query;
+  }
+
+  parseAlpha(alpha) {
+    if (typeof alpha !== "number") {
+      throw new Error("hybrid filter: alpha must be a number");
+    }
+
+    this.alpha = alpha;
+  }
+}

graphql/journey.test.js

@@ -151,6 +151,58 @@ describe("the graphql journey", () => {
       .catch((e) => fail("it should not have error'd" + e));
   });
 
+  test("graphql get bm25 with query (without properties)", () => {
+    return client.graphql
+      .get()
+      .withClassName("Article")
+      .withBm25({ query: "Article", })
+      .withFields("_additional { id }")
+      .do()
+      .then((res) => {
+        expect(res.data.Get.Article.length).toBe(3);
+      })
+      .catch((e) => fail("it should not have error'd" + e));
+  });
+
+  test("graphql get bm25 with query (with properties)", () => {
+    return client.graphql
+      .get()
+      .withClassName("Article")
+      .withBm25({ query: "Article", properties: ["title", "url"]})
+      .withFields("_additional { id }")
+      .do()
+      .then((res) => {
+        expect(res.data.Get.Article.length).toBe(3);
+      })
+      .catch((e) => fail("it should not have error'd" + e));
+  });
+
+  test("graphql get hybrid with query (no vector)", () => {
+    return client.graphql
+      .get()
+      .withClassName("Article")
+      .withHybrid({ query: "Apple", alpha: 3})
+      .withFields("_additional { id }")
+      .do()
+      .then((res) => {
+        expect(res.data.Get.Article.length).toBe(3);
+      })
+      .catch((e) => fail("it should not have error'd" + e));
+  });
+
+  test("graphql get hybrid with query (with vector)", () => {
+    return client.graphql
+      .get()
+      .withClassName("Article")
+      .withHybrid({ query: "Apple", alpha: 0.3, vector: [0.1, 0.2, 0.3]})
+      .withFields("_additional { id }")
+      .do()
+      .then((res) => {
+        expect(res.data.Get.Article.length).toBe(3);
+      })
+      .catch((e) => fail("it should not have error'd" + e));
+  });
+
   test("graphql get with nearText (with certainty)", () => {
     return client.graphql
       .get()

schema/journey.test.js

@@ -451,6 +451,7 @@ function newClassObject(className) {
       desiredVirtualCount: 128,
       function: "murmur3",
       key: "_id",
+      replicas: 1,
       strategy: "hash",
       virtualPerPhysical: 128,
     },