feat(core): Add support for boolean metadata attributes in FunctionalTranslator

langchain-core/src/structured_query/base.ts

@@ -100,7 +100,7 @@ export class BasicTranslator<
         this.allowedComparators.indexOf(func as Comparator) === -1
       ) {
         throw new Error(
-          `Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(
+          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(
             ", "
           )}`
         );

langchain-core/src/structured_query/functional.ts

@@ -17,8 +17,8 @@ import { castValue, isFilterEmpty } from "./utils.js";
  * the result of a comparison operation.
  */
 type ValueType = {
-  eq: string | number;
-  ne: string | number;
+  eq: string | number | boolean;
+  ne: string | number | boolean;
   lt: string | number;
   lte: string | number;
   gt: string | number;
@@ -65,7 +65,29 @@ export class FunctionalTranslator extends BaseTranslator {
   formatFunction(): string {
     throw new Error("Not implemented");
   }
-
+
+  /**
+   * Returns the allowed comparators for a given data type.
+   * @param input The input value to get the allowed comparators for.
+   * @returns An array of allowed comparators for the input data type.
+   */
+  getAllowedComparatorsForType(inputType: string): Comparator[] {
+    switch (inputType) {
+      case "string": {
+        return [Comparators.eq, Comparators.ne, Comparators.gt, Comparators.gte, Comparators.lt, Comparators.lte];
+      }
+      case "number": {
+        return [Comparators.eq, Comparators.ne, Comparators.gt, Comparators.gte, Comparators.lt, Comparators.lte];
+      }
+      case "boolean": {
+        return [Comparators.eq, Comparators.ne];
+      }
+      default: {
+        throw new Error(`Unsupported data type: ${inputType}`);
+      }
+    }
+  }
+
   /**
    * Returns a function that performs a comparison based on the provided
    * comparator.
@@ -159,6 +181,9 @@ export class FunctionalTranslator extends BaseTranslator {
     const { comparator, attribute, value } = comparison;
     const undefinedTrue = [Comparators.ne];
     if (this.allowedComparators.includes(comparator)) {
+      if (!this.getAllowedComparatorsForType(typeof value).includes(comparator)) {
+        throw new Error(`'${comparator}' comparator not allowed to be used with ${typeof value}`);
+      }
       const comparatorFunction = this.getComparatorFunction(comparator);
       return (document: Document) => {
         const documentValue = document.metadata[attribute];

langchain-core/src/structured_query/ir.ts

@@ -82,7 +82,7 @@ export type VisitorOperationResult = {
  */
 export type VisitorComparisonResult = {
   [attr: string]: {
-    [comparator: string]: string | number;
+    [comparator: string]: string | number | boolean;
   };
 };
 
@@ -155,7 +155,7 @@ export class Comparison extends FilterDirective {
   constructor(
     public comparator: Comparator,
     public attribute: string,
-    public value: string | number
+    public value: string | number | boolean
   ) {
     super();
   }

langchain-core/src/structured_query/tests/functional.test.ts

@@ -0,0 +1,246 @@
+import { test, expect } from "@jest/globals";
+import { Document } from "../../documents/document.js";
+import { FunctionalTranslator } from "../functional.js";
+import { Comparators, Visitor } from "../ir.js";
+
+describe("FunctionalTranslator", () => {
+  const translator = new FunctionalTranslator();
+
+  describe("getAllowedComparatorsForType", () => {
+    test("string", () => {
+      expect(translator.getAllowedComparatorsForType("string")).toEqual([
+        Comparators.eq,
+        Comparators.ne,
+        Comparators.gt,
+        Comparators.gte,
+        Comparators.lt,
+        Comparators.lte,
+      ]);
+    });
+    test("number", () => {
+      expect(translator.getAllowedComparatorsForType("number")).toEqual([
+        Comparators.eq,
+        Comparators.ne,
+        Comparators.gt,
+        Comparators.gte,
+        Comparators.lt,
+        Comparators.lte,
+      ]);
+    });
+    test("boolean", () => {
+      expect(translator.getAllowedComparatorsForType("boolean")).toEqual([
+        Comparators.eq,
+        Comparators.ne,
+      ]);
+    });
+    test("unsupported", () => {
+      expect(() =>
+        translator.getAllowedComparatorsForType("unsupported")
+      ).toThrow("Unsupported data type: unsupported");
+    });
+  });
+
+  describe("visitComparison", () => {
+    describe("returns true or false for valid comparisons", () => {
+      const attributesByType = {
+        string: "stringValue",
+        number: "numberValue",
+        boolean: "booleanValue",
+      };
+
+      const inputValuesByAttribute: { [key in string]: string | number | boolean } = {
+        stringValue: "value",
+        numberValue: 1,
+        booleanValue: true,
+      };
+
+      // documents that will match against the comparison
+      const validDocumentsByComparator: { [key in string]: Document<Record<string, unknown>>[] } = {
+        [Comparators.eq]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.ne]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "not-value",
+              numberValue: 0,
+              booleanValue: false,
+            },
+          }),
+        ],
+        [Comparators.gt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.gte]: [
+          // test for greater than
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+          // test for equal to
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.lt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "val",
+              numberValue: 0,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.lte]: [
+          // test for less than
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "val",
+              numberValue: 0,
+              booleanValue: true,
+            },
+          }),
+          // test for equal to
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+      };
+
+      // documents that will not match against the comparison
+      const invalidDocumentsByComparator: { [key in string]: Document<Record<string, unknown>>[] } = {
+        [Comparators.eq]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "not-value",
+              numberValue: 0,
+              booleanValue: false,
+            },
+          }),
+        ],
+        [Comparators.ne]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.gt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.gte]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "val",
+              numberValue: 0,
+              booleanValue: false,
+            },
+          }),
+        ],
+        [Comparators.lt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.lte]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+        ],
+      };
+
+      function generateComparatorTestsForType(type: "string" | "number" | "boolean") {
+        const comparators = translator.getAllowedComparatorsForType(type);
+        for (const comparator of comparators) {
+          const attribute = attributesByType[type];
+          const value = inputValuesByAttribute[attribute];
+          const validDocuments = validDocumentsByComparator[comparator];
+          for (const validDocument of validDocuments) {
+            test(`${value} -> ${comparator} -> ${validDocument.metadata[attribute]}`, () => {
+              const comparison = translator.visitComparison({
+                attribute,
+                comparator,
+                value,
+                exprName: "Comparison",
+                accept: (visitor: Visitor) => visitor,
+              });
+              const result = comparison(validDocument);
+              expect(result).toBeTruthy();
+            });
+          }
+          const invalidDocuments = invalidDocumentsByComparator[comparator];
+          for (const invalidDocument of invalidDocuments) {
+            test(`${value} -> ${comparator} -> ${invalidDocument.metadata[attribute]}`, () => {
+              const comparison = translator.visitComparison({
+                attribute,
+                comparator,
+                value,
+                exprName: "Comparison",
+                accept: (visitor: Visitor) => visitor,
+              });
+              const result = comparison(invalidDocument);
+              expect(result).toBeFalsy();
+            });
+          }
+        }
+      }
+
+      generateComparatorTestsForType("string");
+      generateComparatorTestsForType("number");
+      generateComparatorTestsForType("boolean");
+    });
+  });
+});

langchain-core/src/structured_query/tests/utils.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-process-env */
 import { test, expect } from "@jest/globals";
-import { castValue, isFloat, isInt, isString } from "../utils.js";
+import { castValue, isFloat, isInt, isString, isBoolean } from "../utils.js";
 
 test("Casting values correctly", () => {
   const stringString = [
@@ -28,6 +28,8 @@ test("Casting values correctly", () => {
 
   const floatFloat = ["1.1", 2.2, 3.3];
 
+  const booleanBoolean = [true, false];
+
   stringString.map(castValue).forEach((value) => {
     expect(typeof value).toBe("string");
     expect(isString(value)).toBe(true);
@@ -54,4 +56,9 @@ test("Casting values correctly", () => {
     expect(typeof value).toBe("number");
     expect(isFloat(value)).toBe(true);
   });
+
+  booleanBoolean.map(castValue).forEach((value) => {
+    expect(typeof value).toBe("boolean");
+    expect(isBoolean(value)).toBe(true);
+  });
 });

langchain-core/src/structured_query/utils.ts

@@ -72,20 +72,29 @@ export function isString(value: unknown): boolean {
   );
 }
 
+/**
+ * Checks if the provided value is a boolean.
+ */
+export function isBoolean(value: unknown): boolean {
+    return typeof value === "boolean";
+}
+
 /**
  * Casts a value that might be string or number to actual string or number.
  * Since LLM might return back an integer/float as a string, we need to cast
  * it back to a number, as many vector databases can't handle number as string
  * values as a comparator.
  */
-export function castValue(input: unknown): string | number {
+export function castValue(input: unknown): string | number | boolean {
   let value;
   if (isString(input)) {
     value = input as string;
   } else if (isInt(input)) {
     value = parseInt(input as string, 10);
   } else if (isFloat(input)) {
     value = parseFloat(input as string);
+  } else if (isBoolean(input)) {
+    value = Boolean(input);
   } else {
     throw new Error("Unsupported value type");
   }

langchain/src/chains/query_constructor/parser.ts

@@ -94,7 +94,7 @@ export class QueryTransformer {
               return new Comparison(
                 funcName as Comparator,
                 traverse(node.args[0]) as string,
-                traverse(node.args[1]) as string | number
+                traverse(node.args[1]) as string | number | boolean
               );
             }
             throw new Error("Comparator must have exactly 2 arguments");