langchain 0.0.203 → 0.0.204-rc.0

package/dist/vectorstores/rockset.js

@@ -1,347 +1 @@
-import { Collection } from "@rockset/client/dist/codegen/api.js";
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-/**
- * Generic Rockset vector storage error
- */
-export class RocksetStoreError extends Error {
-    /**
-     * Constructs a RocksetStoreError
-     * @param message   The error message
-     */
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
-    }
-}
-/**
- * Error that is thrown when a RocksetStore function is called
- * after `destroy()` is called (meaning the collection would be
- * deleted).
- */
-export class RocksetStoreDestroyedError extends RocksetStoreError {
-    constructor() {
-        super("The Rockset store has been destroyed");
-        this.name = this.constructor.name;
-    }
-}
-/**
- * Functions to measure vector distance/similarity by.
- * See https://rockset.com/docs/vector-functions/#vector-distance-functions
- * @enum SimilarityMetric
- */
-export const SimilarityMetric = {
-    CosineSimilarity: "COSINE_SIM",
-    EuclideanDistance: "EUCLIDEAN_DIST",
-    DotProduct: "DOT_PRODUCT",
-};
-/**
- * Exposes Rockset's vector store/search functionality
- */
-export class RocksetStore extends VectorStore {
-    /**
-     * Gets a string representation of the type of this VectorStore
-     * @returns {"rockset"}
-     */
-    _vectorstoreType() {
-        return "rockset";
-    }
-    /**
-     * Constructs a new RocksetStore
-     * @param {Embeddings} embeddings  Object used to embed queries and
-     *                                 page content
-     * @param {RocksetLibArgs} args
-     */
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        Object.defineProperty(this, "client", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "collectionName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "workspaceName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "textKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddingKey", {
-            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, "_similarityMetric", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "similarityOrder", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "destroyed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.embeddings = embeddings;
-        this.client = args.client;
-        this.collectionName = args.collectionName;
-        this.workspaceName = args.workspaceName ?? "commons";
-        this.textKey = args.textKey ?? "text";
-        this.embeddingKey = args.embeddingKey ?? "embedding";
-        this.filter = args.filter;
-        this.similarityMetric =
-            args.similarityMetric ?? SimilarityMetric.CosineSimilarity;
-        this.setSimilarityOrder();
-    }
-    /**
-     * Sets the object's similarity order based on what
-     * SimilarityMetric is being used
-     */
-    setSimilarityOrder() {
-        this.checkIfDestroyed();
-        this.similarityOrder =
-            this.similarityMetric === SimilarityMetric.EuclideanDistance
-                ? "ASC"
-                : "DESC";
-    }
-    /**
-     * Embeds and adds Documents to the store.
-     * @param {Documents[]} documents  The documents to store
-     * @returns {Promise<string[]?>}   The _id's of the documents added
-     */
-    async addDocuments(documents) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        return await this.addVectors(await this.embeddings.embedDocuments(texts), documents);
-    }
-    /**
-     * Adds vectors to the store given their corresponding Documents
-     * @param {number[][]} vectors   The vectors to store
-     * @param {Document[]} documents The Documents they represent
-     * @return {Promise<string[]?>}  The _id's of the added documents
-     */
-    async addVectors(vectors, documents) {
-        this.checkIfDestroyed();
-        const rocksetDocs = [];
-        for (let i = 0; i < documents.length; i += 1) {
-            const currDoc = documents[i];
-            const currVector = vectors[i];
-            rocksetDocs.push({
-                [this.textKey]: currDoc.pageContent,
-                [this.embeddingKey]: currVector,
-                ...currDoc.metadata,
-            });
-        }
-        return (await this.client.documents.addDocuments(this.workspaceName, this.collectionName, {
-            data: rocksetDocs,
-        })).data?.map((docStatus) => docStatus._id || "");
-    }
-    /**
-     * Deletes Rockset documements given their _id's
-     * @param {string[]} ids  The IDS to remove documents with
-     */
-    async delete(ids) {
-        this.checkIfDestroyed();
-        await this.client.documents.deleteDocuments(this.workspaceName, this.collectionName, {
-            data: ids.map((id) => ({ _id: id })),
-        });
-    }
-    /**
-     * Gets the most relevant documents to a query along
-     * with their similarity score. The returned documents
-     * are ordered by similarity (most similar at the first
-     * index)
-     * @param {number[]} query  The embedded query to search
-     *                          the store by
-     * @param {number} k        The number of documents to retreive
-     * @param {string?} filter  The SQL `WHERE` clause to filter by
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        this.checkIfDestroyed();
-        if (filter && this.filter) {
-            throw new RocksetStoreError("cannot provide both `filter` and `this.filter`");
-        }
-        const similarityKey = "similarity";
-        const _filter = filter ?? this.filter;
-        return ((await this.client.queries.query({
-            sql: {
-                query: `
-          SELECT
-            * EXCEPT("${this.embeddingKey}"),
-            "${this.textKey}",
-            ${this.similarityMetric}(:query, "${this.embeddingKey}") AS "${similarityKey}"
-          FROM 
-            "${this.workspaceName}"."${this.collectionName}"
-          ${_filter ? `WHERE ${_filter}` : ""}
-          ORDER BY
-            "${similarityKey}" ${this.similarityOrder}
-          LIMIT
-            ${k}
-        `,
-                parameters: [
-                    {
-                        name: "query",
-                        type: "",
-                        value: `[${query.toString()}]`,
-                    },
-                ],
-            },
-        })).results?.map((rocksetDoc) => [
-            new Document({
-                pageContent: rocksetDoc[this.textKey],
-                metadata: (({ [this.textKey]: t, [similarityKey]: s, ...rocksetDoc }) => rocksetDoc)(rocksetDoc),
-            }),
-            rocksetDoc[similarityKey],
-        ]) ?? []);
-    }
-    /**
-     * Constructs and returns a RocksetStore object given texts to store.
-     * @param {string[]} texts               The texts to store
-     * @param {object[] | object} metadatas  The metadatas that correspond
-     *                                       to @param texts
-     * @param {Embeddings} embeddings        The object used to embed queries
-     *                                       and page content
-     * @param {RocksetLibArgs} dbConfig      The options to be passed into the
-     *                                       RocksetStore constructor
-     * @returns {RocksetStore}
-     */
-    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 RocksetStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Constructs, adds docs to, and returns a RocksetStore object
-     * @param {Document[]} docs          The Documents to store
-     * @param {Embeddings} embeddings    The object used to embed queries
-     *                                   and page content
-     * @param {RocksetLibArgs} dbConfig  The options to be passed into the
-     *                                   RocksetStore constructor
-     * @returns {RocksetStore}
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const args = { ...dbConfig, textKey: dbConfig.textKey ?? "text" };
-        const instance = new this(embeddings, args);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Checks if a Rockset collection exists.
-     * @param {RocksetLibArgs} dbConfig  The object containing the collection
-     *                                   and workspace names
-     * @return {boolean}                 whether the collection exists
-     */
-    static async collectionExists(dbConfig) {
-        try {
-            await dbConfig.client.collections.getCollection(dbConfig.workspaceName ?? "commons", dbConfig.collectionName);
-        }
-        catch (err) {
-            if (err.message_key ===
-                "COLLECTION_DOES_NOT_EXIST") {
-                return false;
-            }
-            throw err;
-        }
-        return true;
-    }
-    /**
-     * Checks whether a Rockset collection is ready to be queried.
-     * @param {RocksetLibArgs} dbConfig  The object containing the collection
-     *                                   name and workspace
-     * @return {boolean}                 whether the collection is ready
-     */
-    static async collectionReady(dbConfig) {
-        return ((await dbConfig.client.collections.getCollection(dbConfig.workspaceName ?? "commons", dbConfig.collectionName)).data?.status === Collection.StatusEnum.READY);
-    }
-    /**
-     * Deletes the collection this RocksetStore uses
-     * @param {boolean?} waitUntilDeletion  Whether to sleep until the
-     *                                      collection is ready to be
-     *                                      queried
-     */
-    async destroy(waitUntilDeletion) {
-        await this.client.collections.deleteCollection(this.workspaceName, this.collectionName);
-        this.destroyed = true;
-        if (waitUntilDeletion) {
-            while (await RocksetStore.collectionExists({
-                collectionName: this.collectionName,
-                client: this.client,
-            }))
-                ;
-        }
-    }
-    /**
-     * Checks if this RocksetStore has been destroyed.
-     * @throws {RocksetStoreDestroyederror} if it has.
-     */
-    checkIfDestroyed() {
-        if (this.destroyed) {
-            throw new RocksetStoreDestroyedError();
-        }
-    }
-    /**
-     * Creates a new Rockset collection and returns a RocksetStore that
-     * uses it
-     * @param {Embeddings} embeddings    Object used to embed queries and
-     *                                   page content
-     * @param {RocksetLibArgs} dbConfig  The options to be passed into the
-     *                                   RocksetStore constructor
-     * @param {CreateCollectionRequest?} collectionOptions  The arguments to sent with the
-     *                                                      HTTP request when creating the
-     *                                                      collection. Setting a field mapping
-     *                                                      that `VECTOR_ENFORCE`s is recommended
-     *                                                      when using this function. See
-     *                                                      https://rockset.com/docs/vector-functions/#vector_enforce
-     * @returns {RocsketStore}
-     */
-    static async withNewCollection(embeddings, dbConfig, collectionOptions) {
-        if (collectionOptions?.name &&
-            dbConfig.collectionName !== collectionOptions?.name) {
-            throw new RocksetStoreError("`dbConfig.name` and `collectionOptions.name` do not match");
-        }
-        await dbConfig.client.collections.createCollection(dbConfig.workspaceName ?? "commons", collectionOptions || { name: dbConfig.collectionName });
-        while (!(await this.collectionExists(dbConfig)) ||
-            !(await this.collectionReady(dbConfig)))
-            ;
-        return new this(embeddings, dbConfig);
-    }
-    get similarityMetric() {
-        return this._similarityMetric;
-    }
-    set similarityMetric(metric) {
-        this._similarityMetric = metric;
-        this.setSimilarityOrder();
-    }
-}
+export * from "@langchain/community/vectorstores/rockset";

package/dist/vectorstores/singlestore.cjs

@@ -1,222 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleStoreVectorStore = void 0;
-const mysql2_1 = require("mysql2");
-const promise_1 = require("mysql2/promise");
-const base_js_1 = require("./base.cjs");
-const document_js_1 = require("../document.cjs");
-const OrderingDirective = {
-    DOT_PRODUCT: "DESC",
-    EUCLIDEAN_DISTANCE: "",
+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);
 };
-function withConnectAttributes(config) {
-    let newOptions = {};
-    if (config.connectionURI) {
-        newOptions = {
-            uri: config.connectionURI,
-        };
-    }
-    else if (config.connectionOptions) {
-        newOptions = {
-            ...config.connectionOptions,
-        };
-    }
-    const result = {
-        ...newOptions,
-        connectAttributes: {
-            ...newOptions.connectAttributes,
-        },
-    };
-    if (!result.connectAttributes) {
-        result.connectAttributes = {};
-    }
-    result.connectAttributes = {
-        ...result.connectAttributes,
-        _connector_name: "langchain js sdk",
-        _connector_version: "1.0.0",
-        _driver_name: "Node-MySQL-2",
-    };
-    return result;
-}
-/**
- * Class for interacting with SingleStoreDB, a high-performance
- * distributed SQL database. It provides vector storage and vector
- * functions.
- */
-class SingleStoreVectorStore extends base_js_1.VectorStore {
-    _vectorstoreType() {
-        return "singlestore";
-    }
-    constructor(embeddings, config) {
-        super(embeddings, config);
-        Object.defineProperty(this, "connectionPool", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "tableName", {
-            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, "vectorColumnName", {
-            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, "distanceMetric", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.connectionPool = (0, promise_1.createPool)(withConnectAttributes(config));
-        this.tableName = config.tableName ?? "embeddings";
-        this.contentColumnName = config.contentColumnName ?? "content";
-        this.vectorColumnName = config.vectorColumnName ?? "vector";
-        this.metadataColumnName = config.metadataColumnName ?? "metadata";
-        this.distanceMetric = config.distanceMetric ?? "DOT_PRODUCT";
-    }
-    /**
-     * Creates a new table in the SingleStoreDB database if it does not
-     * already exist.
-     */
-    async createTableIfNotExists() {
-        await this.connectionPool
-            .execute(`CREATE TABLE IF NOT EXISTS ${this.tableName} (
-      ${this.contentColumnName} TEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci,
-      ${this.vectorColumnName} BLOB,
-      ${this.metadataColumnName} JSON);`);
-    }
-    /**
-     * Ends the connection to the SingleStoreDB database.
-     */
-    async end() {
-        return this.connectionPool.end();
-    }
-    /**
-     * Adds new documents to the SingleStoreDB database.
-     * @param documents An array of Document objects.
-     */
-    async addDocuments(documents) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        const vectors = await this.embeddings.embedDocuments(texts);
-        return this.addVectors(vectors, documents);
-    }
-    /**
-     * Adds new vectors to the SingleStoreDB database.
-     * @param vectors An array of vectors.
-     * @param documents An array of Document objects.
-     */
-    async addVectors(vectors, documents) {
-        await this.createTableIfNotExists();
-        const { tableName } = this;
-        await Promise.all(vectors.map(async (vector, idx) => {
-            try {
-                await this.connectionPool.execute((0, mysql2_1.format)(`INSERT INTO ${tableName} VALUES (?, JSON_ARRAY_PACK('[?]'), ?);`, [
-                    documents[idx].pageContent,
-                    vector,
-                    JSON.stringify(documents[idx].metadata),
-                ]));
-            }
-            catch (error) {
-                console.error(`Error adding vector at index ${idx}:`, error);
-            }
-        }));
-    }
-    /**
-     * Performs a similarity search on the vectors stored in the SingleStoreDB
-     * database.
-     * @param query An array of numbers representing the query vector.
-     * @param k The number of nearest neighbors to return.
-     * @param filter Optional metadata to filter the vectors by.
-     * @returns Top matching vectors with score
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        // build the where clause from filter
-        const whereArgs = [];
-        const buildWhereClause = (record, argList) => {
-            const whereTokens = [];
-            for (const key in record)
-                if (record[key] !== undefined) {
-                    if (typeof record[key] === "object" &&
-                        record[key] != null &&
-                        !Array.isArray(record[key])) {
-                        whereTokens.push(buildWhereClause(record[key], argList.concat([key])));
-                    }
-                    else {
-                        whereTokens.push(`JSON_EXTRACT_JSON(${this.metadataColumnName}, `.concat(Array.from({ length: argList.length + 1 }, () => "?").join(", "), ") = ?"));
-                        whereArgs.push(...argList, key, JSON.stringify(record[key]));
-                    }
-                }
-            return whereTokens.join(" AND ");
-        };
-        const whereClause = filter
-            ? "WHERE ".concat(buildWhereClause(filter, []))
-            : "";
-        const [rows] = await this.connectionPool.query((0, mysql2_1.format)(`SELECT ${this.contentColumnName},
-      ${this.metadataColumnName},
-      ${this.distanceMetric}(${this.vectorColumnName}, JSON_ARRAY_PACK('[?]')) as __score FROM ${this.tableName} ${whereClause}
-      ORDER BY __score ${OrderingDirective[this.distanceMetric]} LIMIT ?;`, [query, ...whereArgs, k]));
-        const result = [];
-        for (const row of rows) {
-            const rowData = row;
-            result.push([
-                new document_js_1.Document({
-                    pageContent: rowData[this.contentColumnName],
-                    metadata: rowData[this.metadataColumnName],
-                }),
-                Number(rowData.score),
-            ]);
-        }
-        return result;
-    }
-    /**
-     * Creates a new instance of the SingleStoreVectorStore class from a list
-     * of texts.
-     * @param texts An array of strings.
-     * @param metadatas An array of metadata objects.
-     * @param embeddings An Embeddings object.
-     * @param dbConfig A SingleStoreVectorStoreConfig object.
-     * @returns A new SingleStoreVectorStore instance
-     */
-    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
-        const docs = texts.map((text, idx) => {
-            const metadata = Array.isArray(metadatas) ? metadatas[idx] : metadatas;
-            return new document_js_1.Document({
-                pageContent: text,
-                metadata,
-            });
-        });
-        return SingleStoreVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Creates a new instance of the SingleStoreVectorStore class from a list
-     * of Document objects.
-     * @param docs An array of Document objects.
-     * @param embeddings An Embeddings object.
-     * @param dbConfig A SingleStoreVectorStoreConfig object.
-     * @returns A new SingleStoreVectorStore instance
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-}
-exports.SingleStoreVectorStore = SingleStoreVectorStore;
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@langchain/community/vectorstores/singlestore"), exports);

package/dist/vectorstores/singlestore.d.ts

@@ -1,88 +1 @@
-import type { Pool, PoolOptions } from "mysql2/promise";
-import { VectorStore } from "./base.js";
-import { Embeddings } from "../embeddings/base.js";
-import { Document } from "../document.js";
-export type Metadata = Record<string, any>;
-export type DistanceMetrics = "DOT_PRODUCT" | "EUCLIDEAN_DISTANCE";
-export interface ConnectionOptions extends PoolOptions {
-}
-type ConnectionWithUri = {
-    connectionOptions?: never;
-    connectionURI: string;
-};
-type ConnectionWithOptions = {
-    connectionURI?: never;
-    connectionOptions: ConnectionOptions;
-};
-type ConnectionConfig = ConnectionWithUri | ConnectionWithOptions;
-export type SingleStoreVectorStoreConfig = ConnectionConfig & {
-    tableName?: string;
-    contentColumnName?: string;
-    vectorColumnName?: string;
-    metadataColumnName?: string;
-    distanceMetric?: DistanceMetrics;
-};
-/**
- * Class for interacting with SingleStoreDB, a high-performance
- * distributed SQL database. It provides vector storage and vector
- * functions.
- */
-export declare class SingleStoreVectorStore extends VectorStore {
-    connectionPool: Pool;
-    tableName: string;
-    contentColumnName: string;
-    vectorColumnName: string;
-    metadataColumnName: string;
-    distanceMetric: DistanceMetrics;
-    _vectorstoreType(): string;
-    constructor(embeddings: Embeddings, config: SingleStoreVectorStoreConfig);
-    /**
-     * Creates a new table in the SingleStoreDB database if it does not
-     * already exist.
-     */
-    createTableIfNotExists(): Promise<void>;
-    /**
-     * Ends the connection to the SingleStoreDB database.
-     */
-    end(): Promise<void>;
-    /**
-     * Adds new documents to the SingleStoreDB database.
-     * @param documents An array of Document objects.
-     */
-    addDocuments(documents: Document[]): Promise<void>;
-    /**
-     * Adds new vectors to the SingleStoreDB database.
-     * @param vectors An array of vectors.
-     * @param documents An array of Document objects.
-     */
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
-    /**
-     * Performs a similarity search on the vectors stored in the SingleStoreDB
-     * database.
-     * @param query An array of numbers representing the query vector.
-     * @param k The number of nearest neighbors to return.
-     * @param filter Optional metadata to filter the vectors by.
-     * @returns Top matching vectors with score
-     */
-    similaritySearchVectorWithScore(query: number[], k: number, filter?: Metadata): Promise<[Document, number][]>;
-    /**
-     * Creates a new instance of the SingleStoreVectorStore class from a list
-     * of texts.
-     * @param texts An array of strings.
-     * @param metadatas An array of metadata objects.
-     * @param embeddings An Embeddings object.
-     * @param dbConfig A SingleStoreVectorStoreConfig object.
-     * @returns A new SingleStoreVectorStore instance
-     */
-    static fromTexts(texts: string[], metadatas: object[], embeddings: Embeddings, dbConfig: SingleStoreVectorStoreConfig): Promise<SingleStoreVectorStore>;
-    /**
-     * Creates a new instance of the SingleStoreVectorStore class from a list
-     * of Document objects.
-     * @param docs An array of Document objects.
-     * @param embeddings An Embeddings object.
-     * @param dbConfig A SingleStoreVectorStoreConfig object.
-     * @returns A new SingleStoreVectorStore instance
-     */
-    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: SingleStoreVectorStoreConfig): Promise<SingleStoreVectorStore>;
-}
-export {};
+export * from "@langchain/community/vectorstores/singlestore";