langchain 0.0.147 → 0.0.149

package/dist/retrievers/multi_query.js

@@ -0,0 +1,136 @@
+import { LLMChain } from "../chains/llm_chain.js";
+import { PromptTemplate } from "../prompts/prompt.js";
+import { BaseOutputParser } from "../schema/output_parser.js";
+import { BaseRetriever } from "../schema/retriever.js";
+class LineListOutputParser extends BaseOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "retrievers", "multiquery"]
+        });
+    }
+    static lc_name() {
+        return "LineListOutputParser";
+    }
+    async parse(text) {
+        const startKeyIndex = text.indexOf("<questions>");
+        const endKeyIndex = text.indexOf("</questions>");
+        const questionsStartIndex = startKeyIndex === -1 ? 0 : startKeyIndex + "<questions>".length;
+        const questionsEndIndex = endKeyIndex === -1 ? text.length : endKeyIndex;
+        const lines = text
+            .slice(questionsStartIndex, questionsEndIndex)
+            .trim()
+            .split("\n")
+            .filter((line) => line.trim() !== "");
+        return { lines };
+    }
+    getFormatInstructions() {
+        throw new Error("Not implemented.");
+    }
+}
+// Create template
+const DEFAULT_QUERY_PROMPT = /* #__PURE__ */ new PromptTemplate({
+    inputVariables: ["question", "queryCount"],
+    template: `You are an AI language model assistant. Your task is
+to generate {queryCount} different versions of the given user
+question to retrieve relevant documents from a vector database.
+By generating multiple perspectives on the user question,
+your goal is to help the user overcome some of the limitations
+of distance-based similarity search.
+
+Provide these alternative questions separated by newlines between XML tags. For example:
+
+<questions>
+Question 1
+Question 2
+Question 3
+</questions>
+
+Original question: {question}`,
+});
+// Export class
+export class MultiQueryRetriever extends BaseRetriever {
+    static lc_name() {
+        return "MultiQueryRetriever";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "retrievers", "multiquery"]
+        });
+        Object.defineProperty(this, "retriever", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llmChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3
+        });
+        Object.defineProperty(this, "parserKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "lines"
+        });
+        this.retriever = fields.retriever;
+        this.llmChain = fields.llmChain;
+        this.queryCount = fields.queryCount ?? this.queryCount;
+        this.parserKey = fields.parserKey ?? this.parserKey;
+    }
+    static fromLLM(fields) {
+        const { retriever, llm, prompt = DEFAULT_QUERY_PROMPT, queryCount, parserKey, ...rest } = fields;
+        const outputParser = new LineListOutputParser();
+        const llmChain = new LLMChain({ llm, prompt, outputParser });
+        return new this({ retriever, llmChain, queryCount, parserKey, ...rest });
+    }
+    // Generate the different queries for each retrieval, using our llmChain
+    async _generateQueries(question, runManager) {
+        const response = await this.llmChain.call({ question, queryCount: this.queryCount }, runManager?.getChild());
+        const lines = response.text[this.parserKey] || [];
+        if (this.verbose) {
+            console.log(`Generated queries: ${lines}`);
+        }
+        return lines;
+    }
+    // Retrieve documents using the original retriever
+    async _retrieveDocuments(queries, runManager) {
+        const documents = [];
+        for (const query of queries) {
+            const docs = await this.retriever.getRelevantDocuments(query, runManager?.getChild());
+            documents.push(...docs);
+        }
+        return documents;
+    }
+    // Deduplicate the documents that were returned in multiple retrievals
+    _uniqueUnion(documents) {
+        const uniqueDocumentsDict = {};
+        for (const doc of documents) {
+            const key = `${doc.pageContent}:${JSON.stringify(Object.entries(doc.metadata).sort())}`;
+            uniqueDocumentsDict[key] = doc;
+        }
+        const uniqueDocuments = Object.values(uniqueDocumentsDict);
+        return uniqueDocuments;
+    }
+    async _getRelevantDocuments(question, runManager) {
+        const queries = await this._generateQueries(question, runManager);
+        const documents = await this._retrieveDocuments(queries, runManager);
+        const uniqueDocuments = this._uniqueUnion(documents);
+        return uniqueDocuments;
+    }
+}

package/dist/retrievers/self_query/base.cjs

@@ -84,7 +84,7 @@ class BasicTranslator extends BaseTranslator {
     visitComparison(comparison) {
         return {
             [comparison.attribute]: {
-                [this.formatFunction(comparison.comparator)]: comparison.value,
+                [this.formatFunction(comparison.comparator)]: (0, utils_js_1.castValue)(comparison.value),
             },
         };
     }

package/dist/retrievers/self_query/base.js

@@ -1,5 +1,5 @@
 import { Comparators, Operators, Visitor, } from "../../chains/query_constructor/ir.js";
-import { isFilterEmpty } from "./utils.js";
+import { isFilterEmpty, castValue } from "./utils.js";
 /**
  * Abstract class that provides a blueprint for creating specific
  * translator classes. Defines two abstract methods: formatFunction and
@@ -80,7 +80,7 @@ export class BasicTranslator extends BaseTranslator {
     visitComparison(comparison) {
         return {
             [comparison.attribute]: {
-                [this.formatFunction(comparison.comparator)]: comparison.value,
+                [this.formatFunction(comparison.comparator)]: castValue(comparison.value),
             },
         };
     }

package/dist/retrievers/self_query/functional.cjs

@@ -132,7 +132,7 @@ class FunctionalTranslator extends base_js_1.BaseTranslator {
                     }
                     return false;
                 }
-                return comparatorFunction(documentValue, value);
+                return comparatorFunction(documentValue, (0, utils_js_1.castValue)(value));
             };
         }
         else {

package/dist/retrievers/self_query/functional.js

@@ -1,6 +1,6 @@
 import { Comparators, Operators, } from "../../chains/query_constructor/ir.js";
 import { BaseTranslator } from "./base.js";
-import { isFilterEmpty } from "./utils.js";
+import { castValue, isFilterEmpty } from "./utils.js";
 /**
  * A class that extends `BaseTranslator` to translate structured queries
  * into functional filters.
@@ -129,7 +129,7 @@ export class FunctionalTranslator extends BaseTranslator {
                     }
                     return false;
                 }
-                return comparatorFunction(documentValue, value);
+                return comparatorFunction(documentValue, castValue(value));
             };
         }
         else {

package/dist/retrievers/self_query/utils.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
+exports.castValue = exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
 /**
  * Checks if the provided argument is an object and not an array.
  */
@@ -32,16 +32,32 @@ exports.isFilterEmpty = isFilterEmpty;
  * Checks if the provided value is an integer.
  */
 function isInt(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
+    if (typeof value === "number") {
+        return value % 1 === 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseInt(value, 10);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 === 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
 }
 exports.isInt = isInt;
 /**
  * Checks if the provided value is a floating-point number.
  */
 function isFloat(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
+    if (typeof value === "number") {
+        return value % 1 !== 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseFloat(value);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 !== 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
 }
 exports.isFloat = isFloat;
 /**
@@ -49,6 +65,30 @@ exports.isFloat = isFloat;
  * number.
  */
 function isString(value) {
-    return typeof value === "string" && Number.isNaN(parseFloat(value));
+    return (typeof value === "string" &&
+        (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
 }
 exports.isString = isString;
+/**
+ * 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.
+ */
+function castValue(input) {
+    let value;
+    if (isString(input)) {
+        value = input;
+    }
+    else if (isInt(input)) {
+        value = parseInt(input, 10);
+    }
+    else if (isFloat(input)) {
+        value = parseFloat(input);
+    }
+    else {
+        throw new Error("Unsupported value type");
+    }
+    return value;
+}
+exports.castValue = castValue;

package/dist/retrievers/self_query/utils.d.ts

@@ -20,3 +20,10 @@ export declare function isFloat(value: unknown): boolean;
  * number.
  */
 export declare function isString(value: unknown): 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 declare function castValue(input: unknown): string | number;

package/dist/retrievers/self_query/utils.js

@@ -27,20 +27,59 @@ filter) {
  * Checks if the provided value is an integer.
  */
 export function isInt(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
+    if (typeof value === "number") {
+        return value % 1 === 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseInt(value, 10);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 === 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
 }
 /**
  * Checks if the provided value is a floating-point number.
  */
 export function isFloat(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
+    if (typeof value === "number") {
+        return value % 1 !== 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseFloat(value);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 !== 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
 }
 /**
  * Checks if the provided value is a string that cannot be parsed into a
  * number.
  */
 export function isString(value) {
-    return typeof value === "string" && Number.isNaN(parseFloat(value));
+    return (typeof value === "string" &&
+        (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
+}
+/**
+ * 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) {
+    let value;
+    if (isString(input)) {
+        value = input;
+    }
+    else if (isInt(input)) {
+        value = parseInt(input, 10);
+    }
+    else if (isFloat(input)) {
+        value = parseFloat(input);
+    }
+    else {
+        throw new Error("Unsupported value type");
+    }
+    return value;
 }