langchain 0.0.76 → 0.0.78

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js

@@ -0,0 +1,32 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class PropertyAssignmentHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isProperty(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        let name;
+        if (ASTParser.isIdentifier(node.key)) {
+            name = node.key.name;
+        }
+        else if (ASTParser.isStringLiteral(node.key)) {
+            name = node.key.value;
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        if (!name) {
+            throw new Error("Invalid property key");
+        }
+        const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        const value = await this.parentHandler.handle(node.value);
+        return { type: "property_assignment", identifier, value };
+    }
+}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringLiteralHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class StringLiteralHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isStringLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "string_literal", value: text };
+    }
+}
+exports.StringLiteralHandler = StringLiteralHandler;

package/dist/output_parsers/expression_type_handlers/string_literal_handler.d.ts

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { StringLiteralType } from "./types.js";
+export declare class StringLiteralHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.Literal | boolean>;
+    handle(node: ESTree.Literal): Promise<StringLiteralType>;
+}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js

@@ -0,0 +1,18 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class StringLiteralHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isStringLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "string_literal", value: text };
+    }
+}

package/dist/output_parsers/expression_type_handlers/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/output_parsers/expression_type_handlers/types.d.ts

@@ -0,0 +1,41 @@
+export type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;
+export type ParsedType = ArgumentsType | PropertyAssignmentType;
+export type ArrayLiteralType = {
+    type: "array_literal";
+    values: ArgumentsType[];
+};
+export type BooleanLiteralType = {
+    type: "boolean_literal";
+    value: boolean;
+};
+export type CallExpressionType = {
+    type: "call_expression";
+    funcCall: string | MemberExpressionType;
+    args?: ArgumentsType[];
+};
+export type NumericLiteralType = {
+    type: "numeric_literal";
+    value: number;
+};
+export type ObjectLiteralType = {
+    type: "object_literal";
+    values: PropertyAssignmentType[];
+};
+export type MemberExpressionType = {
+    type: "member_expression";
+    identifier: string;
+    property: string;
+};
+export type PropertyAssignmentType = {
+    type: "property_assignment";
+    identifier: string;
+    value: ArgumentsType;
+};
+export type StringLiteralType = {
+    type: "string_literal";
+    value: string;
+};
+export type IdentifierType = {
+    type: "identifier";
+    value: string;
+};

package/dist/output_parsers/expression_type_handlers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/output_parsers/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomListOutputParser = exports.RouterOutputParser = exports.CombiningOutputParser = exports.OutputFixingParser = exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = exports.RegexParser = exports.CommaSeparatedListOutputParser = exports.ListOutputParser = void 0;
+exports.CustomListOutputParser = exports.RouterOutputParser = exports.CombiningOutputParser = exports.OutputFixingParser = exports.JsonMarkdownStructuredOutputParser = exports.AsymmetricStructuredOutputParser = exports.StructuredOutputParser = exports.RegexParser = exports.CommaSeparatedListOutputParser = exports.ListOutputParser = void 0;
 var list_js_1 = require("./list.cjs");
 Object.defineProperty(exports, "ListOutputParser", { enumerable: true, get: function () { return list_js_1.ListOutputParser; } });
 Object.defineProperty(exports, "CommaSeparatedListOutputParser", { enumerable: true, get: function () { return list_js_1.CommaSeparatedListOutputParser; } });
@@ -8,6 +8,7 @@ var regex_js_1 = require("./regex.cjs");
 Object.defineProperty(exports, "RegexParser", { enumerable: true, get: function () { return regex_js_1.RegexParser; } });
 var structured_js_1 = require("./structured.cjs");
 Object.defineProperty(exports, "StructuredOutputParser", { enumerable: true, get: function () { return structured_js_1.StructuredOutputParser; } });
+Object.defineProperty(exports, "AsymmetricStructuredOutputParser", { enumerable: true, get: function () { return structured_js_1.AsymmetricStructuredOutputParser; } });
 Object.defineProperty(exports, "JsonMarkdownStructuredOutputParser", { enumerable: true, get: function () { return structured_js_1.JsonMarkdownStructuredOutputParser; } });
 var fix_js_1 = require("./fix.cjs");
 Object.defineProperty(exports, "OutputFixingParser", { enumerable: true, get: function () { return fix_js_1.OutputFixingParser; } });

package/dist/output_parsers/index.d.ts

@@ -1,6 +1,6 @@
 export { ListOutputParser, CommaSeparatedListOutputParser } from "./list.js";
 export { RegexParser } from "./regex.js";
-export { StructuredOutputParser, JsonMarkdownStructuredOutputParser, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParserInput, } from "./structured.js";
+export { StructuredOutputParser, AsymmetricStructuredOutputParser, JsonMarkdownStructuredOutputParser, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParserInput, } from "./structured.js";
 export { OutputFixingParser } from "./fix.js";
 export { CombiningOutputParser } from "./combining.js";
 export { RouterOutputParser, RouterOutputParserInput } from "./router.js";

package/dist/output_parsers/index.js

@@ -1,6 +1,6 @@
 export { ListOutputParser, CommaSeparatedListOutputParser } from "./list.js";
 export { RegexParser } from "./regex.js";
-export { StructuredOutputParser, JsonMarkdownStructuredOutputParser, } from "./structured.js";
+export { StructuredOutputParser, AsymmetricStructuredOutputParser, JsonMarkdownStructuredOutputParser, } from "./structured.js";
 export { OutputFixingParser } from "./fix.js";
 export { CombiningOutputParser } from "./combining.js";
 export { RouterOutputParser } from "./router.js";

package/dist/output_parsers/structured.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = void 0;
+exports.AsymmetricStructuredOutputParser = exports.JsonMarkdownStructuredOutputParser = exports.StructuredOutputParser = void 0;
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const output_parser_js_1 = require("../schema/output_parser.cjs");
@@ -63,31 +63,89 @@ class JsonMarkdownStructuredOutputParser extends StructuredOutputParser {
     }
     _schemaToInstruction(schemaInput, indent = 2) {
         const schema = schemaInput;
-        let nullable = false;
-        if (Array.isArray(schema.type)) {
-            const [actualType, nullStr] = schema.type;
-            nullable = nullStr === "null";
-            schema.type = actualType;
-        }
-        if (schema.type === "object" && schema.properties) {
+        if ("type" in schema) {
+            let nullable = false;
+            let type;
+            if (Array.isArray(schema.type)) {
+                const nullIdx = schema.type.findIndex((type) => type === "null");
+                if (nullIdx !== -1) {
+                    nullable = true;
+                    schema.type.splice(nullIdx, 1);
+                }
+                type = schema.type.join(" | ");
+            }
+            else {
+                type = schema.type;
+            }
+            if (schema.type === "object" && schema.properties) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                const properties = Object.entries(schema.properties)
+                    .map(([key, value]) => {
+                    const isOptional = schema.required?.includes(key)
+                        ? ""
+                        : " (optional)";
+                    return `${" ".repeat(indent)}"${key}": ${this._schemaToInstruction(value, indent + 2)}${isOptional}`;
+                })
+                    .join("\n");
+                return `{\n${properties}\n${" ".repeat(indent - 2)}}${description}`;
+            }
+            if (schema.type === "array" && schema.items) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                return `array[\n${" ".repeat(indent)}${this._schemaToInstruction(schema.items, indent + 2)}\n${" ".repeat(indent - 2)}] ${description}`;
+            }
+            const isNullable = nullable ? " (nullable)" : "";
             const description = schema.description ? ` // ${schema.description}` : "";
-            const properties = Object.entries(schema.properties)
-                .map(([key, value]) => {
-                const isOptional = schema.required?.includes(key)
-                    ? ""
-                    : " (optional)";
-                return `${" ".repeat(indent)}"${key}": ${this._schemaToInstruction(value, indent + 2)}${isOptional}`;
-            })
-                .join("\n");
-            return `{\n${properties}\n${" ".repeat(indent - 2)}}${description}`;
+            return `${type}${description}${isNullable}`;
         }
-        if (schema.type === "array" && schema.items) {
-            const description = schema.description ? ` // ${schema.description}` : "";
-            return `array[\n${" ".repeat(indent)}${this._schemaToInstruction(schema.items)}\n${" ".repeat(indent - 2)}] ${description}`;
+        if ("anyOf" in schema) {
+            return schema.anyOf
+                .map((s) => this._schemaToInstruction(s, indent))
+                .join(`\n${" ".repeat(indent - 2)}`);
         }
-        const isNullable = nullable ? " (nullable)" : "";
-        const description = schema.description ? ` // ${schema.description}` : "";
-        return `${schema.type}${description}${isNullable}`;
+        throw new Error("unsupported schema type");
+    }
+    static fromZodSchema(schema) {
+        return new this(schema);
+    }
+    static fromNamesAndDescriptions(schemas) {
+        const zodSchema = zod_1.z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, zod_1.z.string().describe(description)])));
+        return new this(zodSchema);
     }
 }
 exports.JsonMarkdownStructuredOutputParser = JsonMarkdownStructuredOutputParser;
+class AsymmetricStructuredOutputParser extends output_parser_js_1.BaseOutputParser {
+    constructor(inputSchema) {
+        super();
+        Object.defineProperty(this, "inputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: inputSchema
+        });
+        Object.defineProperty(this, "structuredInputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.structuredInputParser = new JsonMarkdownStructuredOutputParser(inputSchema);
+    }
+    async parse(text) {
+        let parsedInput;
+        try {
+            parsedInput = await this.structuredInputParser.parse(text);
+        }
+        catch (e) {
+            throw new output_parser_js_1.OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
+        }
+        return this.outputProcessor(parsedInput);
+    }
+    getFormatInstructions() {
+        return this.structuredInputParser.getFormatInstructions();
+    }
+}
+exports.AsymmetricStructuredOutputParser = AsymmetricStructuredOutputParser;

package/dist/output_parsers/structured.d.ts

@@ -25,4 +25,22 @@ export declare class StructuredOutputParser<T extends z.ZodTypeAny> extends Base
 export declare class JsonMarkdownStructuredOutputParser<T extends z.ZodTypeAny> extends StructuredOutputParser<T> {
     getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;
     private _schemaToInstruction;
+    static fromZodSchema<T extends z.ZodTypeAny>(schema: T): JsonMarkdownStructuredOutputParser<T>;
+    static fromNamesAndDescriptions<S extends {
+        [key: string]: string;
+    }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{
+        [k: string]: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        [x: string]: string;
+    }, {
+        [x: string]: string;
+    }>>;
+}
+export declare abstract class AsymmetricStructuredOutputParser<T extends z.ZodTypeAny, Y = unknown> extends BaseOutputParser<Y> {
+    inputSchema: T;
+    private structuredInputParser;
+    constructor(inputSchema: T);
+    abstract outputProcessor(input: z.infer<T>): Promise<Y>;
+    parse(text: string): Promise<Y>;
+    getFormatInstructions(): string;
 }

package/dist/output_parsers/structured.js

@@ -59,30 +59,87 @@ export class JsonMarkdownStructuredOutputParser extends StructuredOutputParser {
     }
     _schemaToInstruction(schemaInput, indent = 2) {
         const schema = schemaInput;
-        let nullable = false;
-        if (Array.isArray(schema.type)) {
-            const [actualType, nullStr] = schema.type;
-            nullable = nullStr === "null";
-            schema.type = actualType;
-        }
-        if (schema.type === "object" && schema.properties) {
+        if ("type" in schema) {
+            let nullable = false;
+            let type;
+            if (Array.isArray(schema.type)) {
+                const nullIdx = schema.type.findIndex((type) => type === "null");
+                if (nullIdx !== -1) {
+                    nullable = true;
+                    schema.type.splice(nullIdx, 1);
+                }
+                type = schema.type.join(" | ");
+            }
+            else {
+                type = schema.type;
+            }
+            if (schema.type === "object" && schema.properties) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                const properties = Object.entries(schema.properties)
+                    .map(([key, value]) => {
+                    const isOptional = schema.required?.includes(key)
+                        ? ""
+                        : " (optional)";
+                    return `${" ".repeat(indent)}"${key}": ${this._schemaToInstruction(value, indent + 2)}${isOptional}`;
+                })
+                    .join("\n");
+                return `{\n${properties}\n${" ".repeat(indent - 2)}}${description}`;
+            }
+            if (schema.type === "array" && schema.items) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                return `array[\n${" ".repeat(indent)}${this._schemaToInstruction(schema.items, indent + 2)}\n${" ".repeat(indent - 2)}] ${description}`;
+            }
+            const isNullable = nullable ? " (nullable)" : "";
             const description = schema.description ? ` // ${schema.description}` : "";
-            const properties = Object.entries(schema.properties)
-                .map(([key, value]) => {
-                const isOptional = schema.required?.includes(key)
-                    ? ""
-                    : " (optional)";
-                return `${" ".repeat(indent)}"${key}": ${this._schemaToInstruction(value, indent + 2)}${isOptional}`;
-            })
-                .join("\n");
-            return `{\n${properties}\n${" ".repeat(indent - 2)}}${description}`;
+            return `${type}${description}${isNullable}`;
         }
-        if (schema.type === "array" && schema.items) {
-            const description = schema.description ? ` // ${schema.description}` : "";
-            return `array[\n${" ".repeat(indent)}${this._schemaToInstruction(schema.items)}\n${" ".repeat(indent - 2)}] ${description}`;
+        if ("anyOf" in schema) {
+            return schema.anyOf
+                .map((s) => this._schemaToInstruction(s, indent))
+                .join(`\n${" ".repeat(indent - 2)}`);
         }
-        const isNullable = nullable ? " (nullable)" : "";
-        const description = schema.description ? ` // ${schema.description}` : "";
-        return `${schema.type}${description}${isNullable}`;
+        throw new Error("unsupported schema type");
+    }
+    static fromZodSchema(schema) {
+        return new this(schema);
+    }
+    static fromNamesAndDescriptions(schemas) {
+        const zodSchema = z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, z.string().describe(description)])));
+        return new this(zodSchema);
+    }
+}
+export class AsymmetricStructuredOutputParser extends BaseOutputParser {
+    constructor(inputSchema) {
+        super();
+        Object.defineProperty(this, "inputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: inputSchema
+        });
+        Object.defineProperty(this, "structuredInputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.structuredInputParser = new JsonMarkdownStructuredOutputParser(inputSchema);
+    }
+    async parse(text) {
+        let parsedInput;
+        try {
+            parsedInput = await this.structuredInputParser.parse(text);
+        }
+        catch (e) {
+            throw new OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
+        }
+        return this.outputProcessor(parsedInput);
+    }
+    getFormatInstructions() {
+        return this.structuredInputParser.getFormatInstructions();
     }
 }

package/dist/retrievers/self_query/index.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfQueryRetriever = exports.BasicTranslator = exports.BaseTranslator = void 0;
+const index_js_1 = require("../../chains/query_constructor/index.cjs");
+const index_js_2 = require("../../schema/index.cjs");
+const translator_js_1 = require("./translator.cjs");
+Object.defineProperty(exports, "BaseTranslator", { enumerable: true, get: function () { return translator_js_1.BaseTranslator; } });
+Object.defineProperty(exports, "BasicTranslator", { enumerable: true, get: function () { return translator_js_1.BasicTranslator; } });
+class SelfQueryRetriever extends index_js_2.BaseRetriever {
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "vectorStore", {
+            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, "verbose", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "structuredQueryTranslator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "searchParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { k: 4 }
+        });
+        this.vectorStore = options.vectorStore;
+        this.llmChain = options.llmChain;
+        this.verbose = options.verbose ?? false;
+        this.searchParams = options.searchParams ?? this.searchParams;
+        this.structuredQueryTranslator = options.structuredQueryTranslator;
+    }
+    async getRelevantDocuments(query) {
+        const { [this.llmChain.outputKey]: output } = await this.llmChain.call({
+            [this.llmChain.inputKeys[0]]: query,
+        });
+        const nextArg = this.structuredQueryTranslator.visitStructuredQuery(output);
+        if (nextArg.filter) {
+            return this.vectorStore.similaritySearch(query, this.searchParams?.k, nextArg.filter);
+        }
+        else {
+            return this.vectorStore.similaritySearch(query, this.searchParams?.k, this.searchParams?.filter);
+        }
+    }
+    static fromLLM(opts) {
+        const { structuredQueryTranslator } = opts;
+        const allowedComparators = opts.allowedComparators ?? structuredQueryTranslator.allowedComparators;
+        const allowedOperators = opts.allowedOperators ?? structuredQueryTranslator.allowedOperators;
+        const llmChain = (0, index_js_1.loadQueryContstructorChain)({
+            llm: opts.llm,
+            documentContents: opts.documentContents,
+            attributeInfo: opts.attributeInfo,
+            examples: opts.examples,
+            allowedComparators,
+            allowedOperators,
+        });
+        return new SelfQueryRetriever({
+            vectorStore: opts.vectorStore,
+            llmChain,
+            structuredQueryTranslator,
+        });
+    }
+}
+exports.SelfQueryRetriever = SelfQueryRetriever;

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

@@ -0,0 +1,33 @@
+import { LLMChain } from "../../chains/llm_chain.js";
+import { QueryConstructorChainOptions } from "../../chains/query_constructor/index.js";
+import { Document } from "../../document.js";
+import { BaseRetriever } from "../../schema/index.js";
+import { VectorStore } from "../../vectorstores/base.js";
+import { BaseTranslator, BasicTranslator } from "./translator.js";
+export { BaseTranslator, BasicTranslator };
+export type SelfQueryRetrieverArgs = {
+    vectorStore: VectorStore;
+    llmChain: LLMChain;
+    structuredQueryTranslator: BaseTranslator;
+    verbose?: boolean;
+    searchParams?: {
+        k?: number;
+        filter?: VectorStore["FilterType"];
+    };
+};
+export declare class SelfQueryRetriever extends BaseRetriever implements SelfQueryRetrieverArgs {
+    vectorStore: VectorStore;
+    llmChain: LLMChain;
+    verbose?: boolean;
+    structuredQueryTranslator: BaseTranslator;
+    searchParams?: {
+        k?: number;
+        filter?: VectorStore["FilterType"];
+    };
+    constructor(options: SelfQueryRetrieverArgs);
+    getRelevantDocuments(query: string): Promise<Document<Record<string, unknown>>[]>;
+    static fromLLM(opts: QueryConstructorChainOptions & {
+        vectorStore: VectorStore;
+        structuredQueryTranslator: BaseTranslator;
+    }): SelfQueryRetriever;
+}

package/dist/retrievers/self_query/index.js

@@ -0,0 +1,74 @@
+import { loadQueryContstructorChain, } from "../../chains/query_constructor/index.js";
+import { BaseRetriever } from "../../schema/index.js";
+import { BaseTranslator, BasicTranslator } from "./translator.js";
+export { BaseTranslator, BasicTranslator };
+export class SelfQueryRetriever extends BaseRetriever {
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "vectorStore", {
+            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, "verbose", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "structuredQueryTranslator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "searchParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { k: 4 }
+        });
+        this.vectorStore = options.vectorStore;
+        this.llmChain = options.llmChain;
+        this.verbose = options.verbose ?? false;
+        this.searchParams = options.searchParams ?? this.searchParams;
+        this.structuredQueryTranslator = options.structuredQueryTranslator;
+    }
+    async getRelevantDocuments(query) {
+        const { [this.llmChain.outputKey]: output } = await this.llmChain.call({
+            [this.llmChain.inputKeys[0]]: query,
+        });
+        const nextArg = this.structuredQueryTranslator.visitStructuredQuery(output);
+        if (nextArg.filter) {
+            return this.vectorStore.similaritySearch(query, this.searchParams?.k, nextArg.filter);
+        }
+        else {
+            return this.vectorStore.similaritySearch(query, this.searchParams?.k, this.searchParams?.filter);
+        }
+    }
+    static fromLLM(opts) {
+        const { structuredQueryTranslator } = opts;
+        const allowedComparators = opts.allowedComparators ?? structuredQueryTranslator.allowedComparators;
+        const allowedOperators = opts.allowedOperators ?? structuredQueryTranslator.allowedOperators;
+        const llmChain = loadQueryContstructorChain({
+            llm: opts.llm,
+            documentContents: opts.documentContents,
+            attributeInfo: opts.attributeInfo,
+            examples: opts.examples,
+            allowedComparators,
+            allowedOperators,
+        });
+        return new SelfQueryRetriever({
+            vectorStore: opts.vectorStore,
+            llmChain,
+            structuredQueryTranslator,
+        });
+    }
+}