langchain 0.0.154 → 0.0.156

package/dist/vectorstores/cloudflare_vectorize.js

@@ -0,0 +1,173 @@
+import * as uuid from "uuid";
+import { VectorStore } from "./base.js";
+import { Document } from "../document.js";
+import { chunkArray } from "../util/chunk.js";
+import { AsyncCaller } from "../util/async_caller.js";
+/**
+ * Class that extends the VectorStore class and provides methods to
+ * interact with the Cloudflare Vectorize vector database.
+ */
+export class CloudflareVectorizeStore extends VectorStore {
+    _vectorstoreType() {
+        return "cloudflare_vectorize";
+    }
+    constructor(embeddings, args) {
+        super(embeddings, args);
+        Object.defineProperty(this, "textKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.embeddings = embeddings;
+        const { index, textKey, ...asyncCallerArgs } = args;
+        if (!index) {
+            throw new Error("Must supply a Vectorize index binding, eg { index: env.VECTORIZE }");
+        }
+        this.index = index;
+        this.textKey = textKey ?? "text";
+        this.caller = new AsyncCaller({
+            maxConcurrency: 6,
+            maxRetries: 0,
+            ...asyncCallerArgs,
+        });
+    }
+    /**
+     * Method that adds documents to the Vectorize database.
+     * @param documents Array of documents to add.
+     * @param options Optional ids for the documents.
+     * @returns Promise that resolves with the ids of the added documents.
+     */
+    async addDocuments(documents, options) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
+    }
+    /**
+     * Method that adds vectors to the Vectorize database.
+     * @param vectors Array of vectors to add.
+     * @param documents Array of documents associated with the vectors.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with the ids of the added vectors.
+     */
+    async addVectors(vectors, documents, options) {
+        const ids = Array.isArray(options) ? options : options?.ids;
+        const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
+        const vectorizeVectors = vectors.map((values, idx) => {
+            const metadata = {
+                ...documents[idx].metadata,
+                [this.textKey]: documents[idx].pageContent,
+            };
+            return {
+                id: documentIds[idx],
+                metadata,
+                values,
+            };
+        });
+        // Stick to a limit of 500 vectors per upsert request
+        const chunkSize = 500;
+        const chunkedVectors = chunkArray(vectorizeVectors, chunkSize);
+        const batchRequests = chunkedVectors.map((chunk) => this.caller.call(async () => this.index.upsert(chunk)));
+        await Promise.all(batchRequests);
+        return documentIds;
+    }
+    /**
+     * Method that deletes vectors from the Vectorize database.
+     * @param params Parameters for the delete operation.
+     * @returns Promise that resolves when the delete operation is complete.
+     */
+    async delete(params) {
+        const batchSize = 1000;
+        const batchedIds = chunkArray(params.ids, batchSize);
+        const batchRequests = batchedIds.map((batchIds) => this.caller.call(async () => this.index.deleteByIds(batchIds)));
+        await Promise.all(batchRequests);
+    }
+    /**
+     * Method that performs a similarity search in the Vectorize database and
+     * returns the results along with their scores.
+     * @param query Query vector for the similarity search.
+     * @param k Number of top results to return.
+     * @returns Promise that resolves with an array of documents and their scores.
+     */
+    async similaritySearchVectorWithScore(query, k) {
+        const results = await this.index.query(query, {
+            returnVectors: true,
+            topK: k,
+        });
+        const result = [];
+        if (results.matches) {
+            for (const res of results.matches) {
+                const { [this.textKey]: pageContent, ...metadata } = res.vector?.metadata ?? {};
+                result.push([
+                    new Document({ metadata, pageContent: pageContent }),
+                    res.score,
+                ]);
+            }
+        }
+        return result;
+    }
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from texts.
+     * @param texts Array of texts to add to the Vectorize database.
+     * @param metadatas Metadata associated with the texts.
+     * @param embeddings Embeddings to use for the texts.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    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({
+                pageContent: texts[i],
+                metadata,
+            });
+            docs.push(newDoc);
+        }
+        return CloudflareVectorizeStore.fromDocuments(docs, embeddings, dbConfig);
+    }
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from documents.
+     * @param docs Array of documents to add to the Vectorize database.
+     * @param embeddings Embeddings to use for the documents.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static async fromDocuments(docs, embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from an existing index.
+     * @param embeddings Embeddings to use for the documents.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static async fromExistingIndex(embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        return instance;
+    }
+}

package/dist/vectorstores/pgvector.cjs

@@ -173,7 +173,7 @@ class PGVectorStore extends base_js_1.VectorStore {
             }
             catch (e) {
                 console.error(e);
-                throw new Error(`Error inserting: ${chunk[1]}`);
+                throw new Error(`Error inserting: ${e.message}`);
             }
         }
     }

package/dist/vectorstores/pgvector.js

@@ -167,7 +167,7 @@ export class PGVectorStore extends VectorStore {
             }
             catch (e) {
                 console.error(e);
-                throw new Error(`Error inserting: ${chunk[1]}`);
+                throw new Error(`Error inserting: ${e.message}`);
             }
         }
     }

package/dist/vectorstores/supabase.d.ts

@@ -54,7 +54,7 @@ export declare class SupabaseVectorStore extends VectorStore {
      * @returns A promise that resolves when the vectors have been deleted.
      */
     delete(params: {
-        ids: string[];
+        ids: string[] | number[];
     }): Promise<void>;
     /**
      * Performs a similarity search on the vector store.

package/dist/vectorstores/vercel_postgres.cjs

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VercelPostgres = void 0;
+const postgres_1 = require("@vercel/postgres");
+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 Vercel Postgres vector database. It
+ * extends the `VectorStore` base class and implements methods for adding
+ * documents and vectors and performing similarity searches.
+ */
+class VercelPostgres extends base_js_1.VectorStore {
+    _vectorstoreType() {
+        return "vercel";
+    }
+    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 ?? "langchain_vectors";
+        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";
+        this.pool = config.pool;
+        this.client = config.client;
+        this._verbose =
+            (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_VERBOSE") === "true" ??
+                !!config.verbose;
+    }
+    /**
+     * Static method to create a new `VercelPostgres` instance from a
+     * connection. It creates a table if one does not exist, and calls
+     * `connect` to return a new instance of `VercelPostgres`.
+     *
+     * @param embeddings - Embeddings instance.
+     * @param fields - `VercelPostgres` configuration options.
+     * @returns A new instance of `VercelPostgres`.
+     */
+    static async initialize(embeddings, config) {
+        // Default maxUses to 1 for edge environments:
+        // https://github.com/vercel/storage/tree/main/packages/postgres#a-note-on-edge-environments
+        const pool = config?.pool ??
+            (0, postgres_1.createPool)({ maxUses: 1, ...config?.postgresConnectionOptions });
+        const client = config?.client ?? (await pool.connect());
+        const postgresqlVectorStore = new VercelPostgres(embeddings, {
+            ...config,
+            pool,
+            client,
+        });
+        await postgresqlVectorStore.ensureTableInDatabase();
+        return postgresqlVectorStore;
+    }
+    /**
+     * 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, options) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
+    }
+    /**
+     * 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(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    row, index) {
+        const base = index * row.length;
+        return `(${row.map((_, j) => `$${base + 1 + j}`)})`;
+    }
+    /**
+     * 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.
+     */
+    async runInsertQuery(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rows, useIdColumn) {
+        const values = rows.map((row, j) => this.generatePlaceholderForRowAt(row, j));
+        const flatValues = rows.flat();
+        return this.client.query(`
+    INSERT INTO ${this.tableName} (
+      ${useIdColumn ? `${this.idColumnName},` : ""}
+      ${this.contentColumnName}, 
+      ${this.vectorColumnName}, 
+      ${this.metadataColumnName}
+    ) VALUES ${values.join(", ")}
+    ON CONFLICT (${this.idColumnName}) 
+    DO UPDATE 
+    SET 
+    ${this.contentColumnName} = EXCLUDED.${this.contentColumnName},
+    ${this.vectorColumnName} = EXCLUDED.${this.vectorColumnName},
+    ${this.metadataColumnName} = EXCLUDED.${this.metadataColumnName}
+    RETURNING ${this.idColumnName}`, flatValues);
+    }
+    /**
+     * 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, options) {
+        if (options?.ids !== undefined && options?.ids.length !== vectors.length) {
+            throw new Error(`If provided, the length of "ids" must be the same as the number of vectors.`);
+        }
+        const rows = vectors.map((embedding, idx) => {
+            const embeddingString = `[${embedding.join(",")}]`;
+            const row = [
+                documents[idx].pageContent,
+                embeddingString,
+                documents[idx].metadata,
+            ];
+            if (options?.ids) {
+                return [options.ids[idx], ...row];
+            }
+            return row;
+        });
+        const chunkSize = 500;
+        const ids = [];
+        for (let i = 0; i < rows.length; i += chunkSize) {
+            const chunk = rows.slice(i, i + chunkSize);
+            try {
+                const result = await this.runInsertQuery(chunk, options?.ids !== undefined);
+                ids.push(...result.rows.map((row) => row[this.idColumnName]));
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Error inserting: ${e.message}`);
+            }
+        }
+        return ids;
+    }
+    /**
+     * 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.client.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;
+    }
+    async delete(params) {
+        if (params.ids !== undefined) {
+            await this.client.query(`DELETE FROM ${this.tableName} WHERE ${this.idColumnName} IN (${params.ids.map((_, idx) => `$${idx + 1}`)})`, params.ids);
+        }
+        else if (params.deleteAll) {
+            await this.client.query(`TRUNCATE TABLE ${this.tableName}`);
+        }
+    }
+    /**
+     * 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.client.query(`CREATE EXTENSION IF NOT EXISTS vector;`);
+        await this.client.query(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`);
+        await this.client.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 `VercelPostgres` 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 fields - `VercelPostgres` configuration options.
+     * @returns Promise that resolves with a new instance of `VercelPostgres`.
+     */
+    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 this.fromDocuments(docs, embeddings, dbConfig);
+    }
+    /**
+     * Static method to create a new `VercelPostgres` 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 fields - `VercelPostgres` configuration options.
+     * @returns Promise that resolves with a new instance of `VercelPostgres`.
+     */
+    static async fromDocuments(docs, embeddings, dbConfig) {
+        const instance = await this.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.VercelPostgres = VercelPostgres;

package/dist/vectorstores/vercel_postgres.d.ts

@@ -0,0 +1,145 @@
+import { type VercelPool, type VercelPoolClient, type VercelPostgresPoolConfig } from "@vercel/postgres";
+import { VectorStore } from "./base.js";
+import { Embeddings } from "../embeddings/base.js";
+import { Document } from "../document.js";
+type Metadata = Record<string, unknown>;
+/**
+ * Interface that defines the arguments required to create a
+ * `VercelPostgres` instance. It includes Postgres connection options,
+ * table name, filter, and verbosity level.
+ */
+export interface VercelPostgresFields {
+    pool: VercelPool;
+    client: VercelPoolClient;
+    tableName?: string;
+    columns?: {
+        idColumnName?: string;
+        vectorColumnName?: string;
+        contentColumnName?: string;
+        metadataColumnName?: string;
+    };
+    filter?: Metadata;
+    verbose?: boolean;
+}
+/**
+ * Class that provides an interface to a Vercel Postgres vector database. It
+ * extends the `VectorStore` base class and implements methods for adding
+ * documents and vectors and performing similarity searches.
+ */
+export declare class VercelPostgres extends VectorStore {
+    FilterType: Metadata;
+    tableName: string;
+    idColumnName: string;
+    vectorColumnName: string;
+    contentColumnName: string;
+    metadataColumnName: string;
+    filter?: Metadata;
+    _verbose?: boolean;
+    pool: VercelPool;
+    client: VercelPoolClient;
+    _vectorstoreType(): string;
+    private constructor();
+    /**
+     * Static method to create a new `VercelPostgres` instance from a
+     * connection. It creates a table if one does not exist, and calls
+     * `connect` to return a new instance of `VercelPostgres`.
+     *
+     * @param embeddings - Embeddings instance.
+     * @param fields - `VercelPostgres` configuration options.
+     * @returns A new instance of `VercelPostgres`.
+     */
+    static initialize(embeddings: Embeddings, config?: Partial<VercelPostgresFields> & {
+        postgresConnectionOptions?: VercelPostgresPoolConfig;
+    }): Promise<VercelPostgres>;
+    /**
+     * 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.
+     */
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    /**
+     * 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.
+     */
+    protected generatePlaceholderForRowAt(row: (string | Record<string, any>)[], index: number): string;
+    /**
+     * 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.
+     */
+    protected runInsertQuery(rows: (string | Record<string, any>)[][], useIdColumn: boolean): Promise<import("@vercel/postgres").QueryResult<any>>;
+    /**
+     * 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.
+     */
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    /**
+     * 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.
+     */
+    similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    delete(params: {
+        ids?: string[];
+        deleteAll?: boolean;
+    }): Promise<void>;
+    /**
+     * 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.
+     */
+    ensureTableInDatabase(): Promise<void>;
+    /**
+     * Static method to create a new `VercelPostgres` 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 fields - `VercelPostgres` configuration options.
+     * @returns Promise that resolves with a new instance of `VercelPostgres`.
+     */
+    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig?: Partial<VercelPostgresFields> & {
+        postgresConnectionOptions?: VercelPostgresPoolConfig;
+    }): Promise<VercelPostgres>;
+    /**
+     * Static method to create a new `VercelPostgres` 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 fields - `VercelPostgres` configuration options.
+     * @returns Promise that resolves with a new instance of `VercelPostgres`.
+     */
+    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig?: Partial<VercelPostgresFields> & {
+        postgresConnectionOptions?: VercelPostgresPoolConfig;
+    }): Promise<VercelPostgres>;
+    /**
+     * 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.
+     */
+    end(): Promise<void>;
+}
+export {};