langchain 0.0.149 → 0.0.151

package/dist/schema/runnable/branch.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnableBranch = void 0;
+const base_js_1 = require("./base.cjs");
+/**
+ * Class that represents a runnable branch. The RunnableBranch is
+ * initialized with an array of branches and a default branch. When invoked,
+ * it evaluates the condition of each branch in order and executes the
+ * corresponding branch if the condition is true. If none of the conditions
+ * are true, it executes the default branch.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class RunnableBranch extends base_js_1.Runnable {
+    static lc_name() {
+        return "RunnableBranch";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "runnable", "branch"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "default", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "branches", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.branches = fields.branches;
+        this.default = fields.default;
+    }
+    /**
+     * Convenience method for instantiating a RunnableBranch from
+     * RunnableLikes (objects, functions, or Runnables).
+     *
+     * Each item in the input except for the last one should be a
+     * tuple with two items. The first is a "condition" RunnableLike that
+     * returns "true" if the second RunnableLike in the tuple should run.
+     *
+     * The final item in the input should be a RunnableLike that acts as a
+     * default branch if no other branches match.
+     *
+     * @example
+     * ```ts
+     * import { RunnableBranch } from "langchain/schema/runnable";
+     *
+     * const branch = RunnableBranch.from([
+     *   [(x: number) => x > 0, (x: number) => x + 1],
+     *   [(x: number) => x < 0, (x: number) => x - 1],
+     *   (x: number) => x
+     * ]);
+     * ```
+     * @param branches An array where the every item except the last is a tuple of [condition, runnable]
+     *   pairs. The last item is a default runnable which is invoked if no other condition matches.
+     * @returns A new RunnableBranch.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static from(branches) {
+        if (branches.length < 1) {
+            throw new Error("RunnableBranch requires at least one branch");
+        }
+        const branchLikes = branches.slice(0, -1);
+        const coercedBranches = branchLikes.map(([condition, runnable]) => [
+            (0, base_js_1._coerceToRunnable)(condition),
+            (0, base_js_1._coerceToRunnable)(runnable),
+        ]);
+        const defaultBranch = (0, base_js_1._coerceToRunnable)(branches[branches.length - 1]);
+        return new this({
+            branches: coercedBranches,
+            default: defaultBranch,
+        });
+    }
+    async _invoke(input, config, runManager) {
+        let result;
+        for (let i = 0; i < this.branches.length; i += 1) {
+            const [condition, branchRunnable] = this.branches[i];
+            const conditionValue = await condition.invoke(input, this._patchConfig(config, runManager?.getChild(`condition:${i + 1}`)));
+            if (conditionValue) {
+                result = await branchRunnable.invoke(input, this._patchConfig(config, runManager?.getChild(`branch:${i + 1}`)));
+                break;
+            }
+        }
+        if (!result) {
+            result = await this.default.invoke(input, this._patchConfig(config, runManager?.getChild("default")));
+        }
+        return result;
+    }
+    async invoke(input, config = {}) {
+        return this._callWithConfig(this._invoke, input, config);
+    }
+}
+exports.RunnableBranch = RunnableBranch;

package/dist/schema/runnable/branch.d.ts

@@ -0,0 +1,66 @@
+import { Runnable, RunnableLike } from "./base.js";
+import { RunnableConfig } from "./config.js";
+import { CallbackManagerForChainRun } from "../../callbacks/manager.js";
+/**
+ * Type for a branch in the RunnableBranch. It consists of a condition
+ * runnable and a branch runnable. The condition runnable is used to
+ * determine whether the branch should be executed, and the branch runnable
+ * is executed if the condition is true.
+ */
+export type Branch<RunInput, RunOutput> = [
+    Runnable<RunInput, boolean>,
+    Runnable<RunInput, RunOutput>
+];
+export type BranchLike<RunInput, RunOutput> = [
+    RunnableLike<RunInput, boolean>,
+    RunnableLike<RunInput, RunOutput>
+];
+/**
+ * Class that represents a runnable branch. The RunnableBranch is
+ * initialized with an array of branches and a default branch. When invoked,
+ * it evaluates the condition of each branch in order and executes the
+ * corresponding branch if the condition is true. If none of the conditions
+ * are true, it executes the default branch.
+ */
+export declare class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    default: Runnable<RunInput, RunOutput>;
+    branches: Branch<RunInput, RunOutput>[];
+    constructor(fields: {
+        branches: Branch<RunInput, RunOutput>[];
+        default: Runnable<RunInput, RunOutput>;
+    });
+    /**
+     * Convenience method for instantiating a RunnableBranch from
+     * RunnableLikes (objects, functions, or Runnables).
+     *
+     * Each item in the input except for the last one should be a
+     * tuple with two items. The first is a "condition" RunnableLike that
+     * returns "true" if the second RunnableLike in the tuple should run.
+     *
+     * The final item in the input should be a RunnableLike that acts as a
+     * default branch if no other branches match.
+     *
+     * @example
+     * ```ts
+     * import { RunnableBranch } from "langchain/schema/runnable";
+     *
+     * const branch = RunnableBranch.from([
+     *   [(x: number) => x > 0, (x: number) => x + 1],
+     *   [(x: number) => x < 0, (x: number) => x - 1],
+     *   (x: number) => x
+     * ]);
+     * ```
+     * @param branches An array where the every item except the last is a tuple of [condition, runnable]
+     *   pairs. The last item is a default runnable which is invoked if no other condition matches.
+     * @returns A new RunnableBranch.
+     */
+    static from<RunInput = any, RunOutput = any>(branches: [
+        ...BranchLike<RunInput, RunOutput>[],
+        RunnableLike<RunInput, RunOutput>
+    ]): RunnableBranch<RunInput, RunOutput>;
+    _invoke(input: RunInput, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
+    invoke(input: RunInput, config?: RunnableConfig): Promise<RunOutput>;
+}

package/dist/schema/runnable/branch.js

@@ -0,0 +1,102 @@
+import { Runnable, _coerceToRunnable } from "./base.js";
+/**
+ * Class that represents a runnable branch. The RunnableBranch is
+ * initialized with an array of branches and a default branch. When invoked,
+ * it evaluates the condition of each branch in order and executes the
+ * corresponding branch if the condition is true. If none of the conditions
+ * are true, it executes the default branch.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class RunnableBranch extends Runnable {
+    static lc_name() {
+        return "RunnableBranch";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "runnable", "branch"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "default", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "branches", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.branches = fields.branches;
+        this.default = fields.default;
+    }
+    /**
+     * Convenience method for instantiating a RunnableBranch from
+     * RunnableLikes (objects, functions, or Runnables).
+     *
+     * Each item in the input except for the last one should be a
+     * tuple with two items. The first is a "condition" RunnableLike that
+     * returns "true" if the second RunnableLike in the tuple should run.
+     *
+     * The final item in the input should be a RunnableLike that acts as a
+     * default branch if no other branches match.
+     *
+     * @example
+     * ```ts
+     * import { RunnableBranch } from "langchain/schema/runnable";
+     *
+     * const branch = RunnableBranch.from([
+     *   [(x: number) => x > 0, (x: number) => x + 1],
+     *   [(x: number) => x < 0, (x: number) => x - 1],
+     *   (x: number) => x
+     * ]);
+     * ```
+     * @param branches An array where the every item except the last is a tuple of [condition, runnable]
+     *   pairs. The last item is a default runnable which is invoked if no other condition matches.
+     * @returns A new RunnableBranch.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static from(branches) {
+        if (branches.length < 1) {
+            throw new Error("RunnableBranch requires at least one branch");
+        }
+        const branchLikes = branches.slice(0, -1);
+        const coercedBranches = branchLikes.map(([condition, runnable]) => [
+            _coerceToRunnable(condition),
+            _coerceToRunnable(runnable),
+        ]);
+        const defaultBranch = _coerceToRunnable(branches[branches.length - 1]);
+        return new this({
+            branches: coercedBranches,
+            default: defaultBranch,
+        });
+    }
+    async _invoke(input, config, runManager) {
+        let result;
+        for (let i = 0; i < this.branches.length; i += 1) {
+            const [condition, branchRunnable] = this.branches[i];
+            const conditionValue = await condition.invoke(input, this._patchConfig(config, runManager?.getChild(`condition:${i + 1}`)));
+            if (conditionValue) {
+                result = await branchRunnable.invoke(input, this._patchConfig(config, runManager?.getChild(`branch:${i + 1}`)));
+                break;
+            }
+        }
+        if (!result) {
+            result = await this.default.invoke(input, this._patchConfig(config, runManager?.getChild("default")));
+        }
+        return result;
+    }
+    async invoke(input, config = {}) {
+        return this._callWithConfig(this._invoke, input, config);
+    }
+}

package/dist/schema/runnable/index.cjs

@@ -1,22 +1,18 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterRunnable = exports.RunnablePassthrough = void 0;
-__exportStar(require("./base.cjs"), exports);
+exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
+var base_js_1 = require("./base.cjs");
+Object.defineProperty(exports, "Runnable", { enumerable: true, get: function () { return base_js_1.Runnable; } });
+Object.defineProperty(exports, "RunnableBinding", { enumerable: true, get: function () { return base_js_1.RunnableBinding; } });
+Object.defineProperty(exports, "RunnableEach", { enumerable: true, get: function () { return base_js_1.RunnableEach; } });
+Object.defineProperty(exports, "RunnableRetry", { enumerable: true, get: function () { return base_js_1.RunnableRetry; } });
+Object.defineProperty(exports, "RunnableSequence", { enumerable: true, get: function () { return base_js_1.RunnableSequence; } });
+Object.defineProperty(exports, "RunnableMap", { enumerable: true, get: function () { return base_js_1.RunnableMap; } });
+Object.defineProperty(exports, "RunnableLambda", { enumerable: true, get: function () { return base_js_1.RunnableLambda; } });
+Object.defineProperty(exports, "RunnableWithFallbacks", { enumerable: true, get: function () { return base_js_1.RunnableWithFallbacks; } });
 var passthrough_js_1 = require("./passthrough.cjs");
 Object.defineProperty(exports, "RunnablePassthrough", { enumerable: true, get: function () { return passthrough_js_1.RunnablePassthrough; } });
 var router_js_1 = require("./router.cjs");
 Object.defineProperty(exports, "RouterRunnable", { enumerable: true, get: function () { return router_js_1.RouterRunnable; } });
+var branch_js_1 = require("./branch.cjs");
+Object.defineProperty(exports, "RunnableBranch", { enumerable: true, get: function () { return branch_js_1.RunnableBranch; } });

package/dist/schema/runnable/index.d.ts

@@ -1,4 +1,5 @@
-export * from "./base.js";
+export { RunnableFunc, RunnableLike, RunnableBatchOptions, RunnableRetryFailedAttemptHandler, Runnable, RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableLambda, RunnableWithFallbacks, } from "./base.js";
 export { RunnableConfig } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { RouterRunnable } from "./router.js";
+export { RunnableBranch, Branch, BranchLike } from "./branch.js";

package/dist/schema/runnable/index.js

@@ -1,3 +1,4 @@
-export * from "./base.js";
+export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableLambda, RunnableWithFallbacks, } from "./base.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { RouterRunnable } from "./router.js";
+export { RunnableBranch } from "./branch.js";

package/dist/vectorstores/pgvector.cjs

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PGVectorStore = void 0;
+const pg_1 = __importDefault(require("pg"));
+const base_js_1 = require("./base.cjs");
+const document_js_1 = require("../document.cjs");
+const env_js_1 = require("../util/env.cjs");
+/**
+ * Class that provides an interface to a Postgres vector database. It
+ * extends the `VectorStore` base class and implements methods for adding
+ * documents and vectors, performing similarity searches, and ensuring the
+ * existence of a table in the database.
+ */
+class PGVectorStore extends base_js_1.VectorStore {
+    _vectorstoreType() {
+        return "pgvector";
+    }
+    constructor(embeddings, config) {
+        super(embeddings, config);
+        Object.defineProperty(this, "tableName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "idColumnName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vectorColumnName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contentColumnName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadataColumnName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filter", {
+            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, "pool", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tableName = config.tableName;
+        this.filter = config.filter;
+        this.vectorColumnName = config.columns?.vectorColumnName ?? "embedding";
+        this.contentColumnName = config.columns?.contentColumnName ?? "text";
+        this.idColumnName = config.columns?.idColumnName ?? "id";
+        this.metadataColumnName = config.columns?.metadataColumnName ?? "metadata";
+        const pool = new pg_1.default.Pool(config.postgresConnectionOptions);
+        this.pool = pool;
+        this._verbose =
+            (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_VERBOSE") === "true" ??
+                !!config.verbose;
+    }
+    /**
+     * Static method to create a new `PGVectorStore` instance from a
+     * connection. It creates a table if one does not exist, and calls
+     * `connect` to return a new instance of `PGVectorStore`.
+     *
+     * @param embeddings - Embeddings instance.
+     * @param fields - `PGVectorStoreArgs` instance.
+     * @returns A new instance of `PGVectorStore`.
+     */
+    static async initialize(embeddings, config) {
+        const postgresqlVectorStore = new PGVectorStore(embeddings, config);
+        await postgresqlVectorStore._initializeClient();
+        await postgresqlVectorStore.ensureTableInDatabase();
+        return postgresqlVectorStore;
+    }
+    async _initializeClient() {
+        this.client = await this.pool.connect();
+    }
+    /**
+     * Method to add documents to the vector store. It converts the documents into
+     * vectors, and adds them to the store.
+     *
+     * @param documents - Array of `Document` instances.
+     * @returns Promise that resolves when the documents have been added.
+     */
+    async addDocuments(documents) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+    }
+    /**
+     * Generates the SQL placeholders for a specific row at the provided index.
+     *
+     * @param index - The index of the row for which placeholders need to be generated.
+     * @returns The SQL placeholders for the row values.
+     */
+    generatePlaceholderForRowAt(index) {
+        const base = index * 3;
+        return `($${base + 1}, $${base + 2}, $${base + 3})`;
+    }
+    /**
+     * Constructs the SQL query for inserting rows into the specified table.
+     *
+     * @param rows - The rows of data to be inserted, consisting of values and records.
+     * @param chunkIndex - The starting index for generating query placeholders based on chunk positioning.
+     * @returns The complete SQL INSERT INTO query string.
+     */
+    buildInsertQuery(rows, chunkIndex) {
+        const valuesPlaceholders = rows
+            .map((_, j) => this.generatePlaceholderForRowAt(chunkIndex + j))
+            .join(", ");
+        const text = `
+      INSERT INTO ${this.tableName}(
+        ${this.contentColumnName},
+        ${this.vectorColumnName},
+        ${this.metadataColumnName}
+      )
+      VALUES ${valuesPlaceholders}
+    `;
+        return text;
+    }
+    /**
+     * Method to add vectors to the vector store. It converts the vectors into
+     * rows and inserts them into the database.
+     *
+     * @param vectors - Array of vectors.
+     * @param documents - Array of `Document` instances.
+     * @returns Promise that resolves when the vectors have been added.
+     */
+    async addVectors(vectors, documents) {
+        const rows = vectors.map((embedding, idx) => {
+            const embeddingString = `[${embedding.join(",")}]`;
+            return [
+                documents[idx].pageContent,
+                embeddingString,
+                documents[idx].metadata,
+            ];
+        });
+        const chunkSize = 500;
+        for (let i = 0; i < rows.length; i += chunkSize) {
+            const chunk = rows.slice(i, i + chunkSize);
+            const insertQuery = this.buildInsertQuery(chunk, i);
+            const flatValues = chunk.flat();
+            try {
+                await this.pool.query(insertQuery, flatValues);
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Error inserting: ${chunk[1]}`);
+            }
+        }
+    }
+    /**
+     * Method to perform a similarity search in the vector store. It returns
+     * the `k` most similar documents to the query vector, along with their
+     * similarity scores.
+     *
+     * @param query - Query vector.
+     * @param k - Number of most similar documents to return.
+     * @param filter - Optional filter to apply to the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
+    async similaritySearchVectorWithScore(query, k, filter) {
+        const embeddingString = `[${query.join(",")}]`;
+        const _filter = filter ?? "{}";
+        const queryString = `
+      SELECT *, ${this.vectorColumnName} <=> $1 as "_distance"
+      FROM ${this.tableName}
+      WHERE ${this.metadataColumnName} @> $2
+      ORDER BY "_distance" ASC
+      LIMIT $3;`;
+        const documents = (await this.pool.query(queryString, [embeddingString, _filter, k])).rows;
+        const results = [];
+        for (const doc of documents) {
+            if (doc._distance != null && doc[this.contentColumnName] != null) {
+                const document = new document_js_1.Document({
+                    pageContent: doc[this.contentColumnName],
+                    metadata: doc[this.metadataColumnName],
+                });
+                results.push([document, doc._distance]);
+            }
+        }
+        return results;
+    }
+    /**
+     * Method to ensure the existence of the table in the database. It creates
+     * the table if it does not already exist.
+     *
+     * @returns Promise that resolves when the table has been ensured.
+     */
+    async ensureTableInDatabase() {
+        await this.pool.query("CREATE EXTENSION IF NOT EXISTS vector;");
+        await this.pool.query('CREATE EXTENSION IF NOT EXISTS "uuid-ossp";');
+        await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        "${this.idColumnName}" uuid NOT NULL DEFAULT uuid_generate_v4() PRIMARY KEY,
+        "${this.contentColumnName}" text,
+        "${this.metadataColumnName}" jsonb,
+        "${this.vectorColumnName}" vector
+      );
+    `);
+    }
+    /**
+     * Static method to create a new `PGVectorStore` instance from an
+     * array of texts and their metadata. It converts the texts into
+     * `Document` instances and adds them to the store.
+     *
+     * @param texts - Array of texts.
+     * @param metadatas - Array of metadata objects or a single metadata object.
+     * @param embeddings - Embeddings instance.
+     * @param dbConfig - `PGVectorStoreArgs` instance.
+     * @returns Promise that resolves with a new instance of `PGVectorStore`.
+     */
+    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
+        const docs = [];
+        for (let i = 0; i < texts.length; i += 1) {
+            const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
+            const newDoc = new document_js_1.Document({
+                pageContent: texts[i],
+                metadata,
+            });
+            docs.push(newDoc);
+        }
+        return PGVectorStore.fromDocuments(docs, embeddings, dbConfig);
+    }
+    /**
+     * Static method to create a new `PGVectorStore` instance from an
+     * array of `Document` instances. It adds the documents to the store.
+     *
+     * @param docs - Array of `Document` instances.
+     * @param embeddings - Embeddings instance.
+     * @param dbConfig - `PGVectorStoreArgs` instance.
+     * @returns Promise that resolves with a new instance of `PGVectorStore`.
+     */
+    static async fromDocuments(docs, embeddings, dbConfig) {
+        const instance = await PGVectorStore.initialize(embeddings, dbConfig);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+    /**
+     * Closes all the clients in the pool and terminates the pool.
+     *
+     * @returns Promise that resolves when all clients are closed and the pool is terminated.
+     */
+    async end() {
+        await this.client?.release();
+        return this.pool.end();
+    }
+}
+exports.PGVectorStore = PGVectorStore;