langchain 0.0.202 → 0.0.204-rc.0

package/dist/vectorstores/singlestore.js

@@ -1,218 +1 @@
-import { format } from "mysql2";
-import { createPool } from "mysql2/promise";
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-const OrderingDirective = {
-    DOT_PRODUCT: "DESC",
-    EUCLIDEAN_DISTANCE: "",
-};
-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.
- */
-export class SingleStoreVectorStore extends 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 = 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(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(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({
-                    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({
-                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;
-    }
-}
+export * from "@langchain/community/vectorstores/singlestore";

package/dist/vectorstores/supabase.cjs

@@ -1,219 +1,17 @@
 "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.SupabaseVectorStore = void 0;
-const base_js_1 = require("./base.cjs");
-const document_js_1 = require("../document.cjs");
-const math_js_1 = require("../util/math.cjs");
-/**
- * Class for interacting with a Supabase database to store and manage
- * vectors.
- */
-class SupabaseVectorStore extends base_js_1.VectorStore {
-    _vectorstoreType() {
-        return "supabase";
-    }
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        Object.defineProperty(this, "client", {
-            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, "queryName", {
-            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, "upsertBatchSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 500
-        });
-        this.client = args.client;
-        this.tableName = args.tableName || "documents";
-        this.queryName = args.queryName || "match_documents";
-        this.filter = args.filter;
-        this.upsertBatchSize = args.upsertBatchSize ?? this.upsertBatchSize;
-    }
-    /**
-     * Adds documents to the vector store.
-     * @param documents The documents to add.
-     * @param options Optional parameters for adding the documents.
-     * @returns A 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);
-    }
-    /**
-     * Adds vectors to the vector store.
-     * @param vectors The vectors to add.
-     * @param documents The documents associated with the vectors.
-     * @param options Optional parameters for adding the vectors.
-     * @returns A promise that resolves with the IDs of the added vectors when the vectors have been added.
-     */
-    async addVectors(vectors, documents, options) {
-        const rows = vectors.map((embedding, idx) => ({
-            content: documents[idx].pageContent,
-            embedding,
-            metadata: documents[idx].metadata,
-        }));
-        // upsert returns 500/502/504 (yes really any of them) if given too many rows/characters
-        // ~2000 trips it, but my data is probably smaller than average pageContent and metadata
-        let returnedIds = [];
-        for (let i = 0; i < rows.length; i += this.upsertBatchSize) {
-            const chunk = rows.slice(i, i + this.upsertBatchSize).map((row, j) => {
-                if (options?.ids) {
-                    return { id: options.ids[i + j], ...row };
-                }
-                return row;
-            });
-            const res = await this.client.from(this.tableName).upsert(chunk).select();
-            if (res.error) {
-                throw new Error(`Error inserting: ${res.error.message} ${res.status} ${res.statusText}`);
-            }
-            if (res.data) {
-                returnedIds = returnedIds.concat(res.data.map((row) => row.id));
-            }
-        }
-        return returnedIds;
-    }
-    /**
-     * Deletes vectors from the vector store.
-     * @param params The parameters for deleting vectors.
-     * @returns A promise that resolves when the vectors have been deleted.
-     */
-    async delete(params) {
-        const { ids } = params;
-        for (const id of ids) {
-            await this.client.from(this.tableName).delete().eq("id", id);
-        }
-    }
-    async _searchSupabase(query, k, filter) {
-        if (filter && this.filter) {
-            throw new Error("cannot provide both `filter` and `this.filter`");
-        }
-        const _filter = filter ?? this.filter ?? {};
-        const matchDocumentsParams = {
-            query_embedding: query,
-        };
-        let filterFunction;
-        if (typeof _filter === "function") {
-            filterFunction = (rpcCall) => _filter(rpcCall).limit(k);
-        }
-        else if (typeof _filter === "object") {
-            matchDocumentsParams.filter = _filter;
-            matchDocumentsParams.match_count = k;
-            filterFunction = (rpcCall) => rpcCall;
-        }
-        else {
-            throw new Error("invalid filter type");
-        }
-        const rpcCall = this.client.rpc(this.queryName, matchDocumentsParams);
-        const { data: searches, error } = await filterFunction(rpcCall);
-        if (error) {
-            throw new Error(`Error searching for documents: ${error.code} ${error.message} ${error.details}`);
-        }
-        return searches;
-    }
-    /**
-     * Performs a similarity search on the vector store.
-     * @param query The query vector.
-     * @param k The number of results to return.
-     * @param filter Optional filter to apply to the search.
-     * @returns A promise that resolves with the search results when the search is complete.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        const searches = await this._searchSupabase(query, k, filter);
-        const result = searches.map((resp) => [
-            new document_js_1.Document({
-                metadata: resp.metadata,
-                pageContent: resp.content,
-            }),
-            resp.similarity,
-        ]);
-        return result;
-    }
-    /**
-     * Return documents selected using the maximal marginal relevance.
-     * Maximal marginal relevance optimizes for similarity to the query AND diversity
-     * among selected documents.
-     *
-     * @param {string} query - Text to look up documents similar to.
-     * @param {number} options.k - Number of documents to return.
-     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
-     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
-     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
-     * @param {SupabaseLibArgs} options.filter - Optional filter to apply to the search.
-     *
-     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
-     */
-    async maxMarginalRelevanceSearch(query, options) {
-        const queryEmbedding = await this.embeddings.embedQuery(query);
-        const searches = await this._searchSupabase(queryEmbedding, options.fetchK ?? 20, options.filter);
-        const embeddingList = searches.map((searchResp) => searchResp.embedding);
-        const mmrIndexes = (0, math_js_1.maximalMarginalRelevance)(queryEmbedding, embeddingList, options.lambda, options.k);
-        return mmrIndexes.map((idx) => new document_js_1.Document({
-            metadata: searches[idx].metadata,
-            pageContent: searches[idx].content,
-        }));
-    }
-    /**
-     * Creates a new SupabaseVectorStore instance from an array of texts.
-     * @param texts The texts to create documents from.
-     * @param metadatas The metadata for the documents.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The configuration for the Supabase database.
-     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
-     */
-    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 SupabaseVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Creates a new SupabaseVectorStore instance from an array of documents.
-     * @param docs The documents to create the instance from.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The configuration for the Supabase database.
-     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Creates a new SupabaseVectorStore instance from an existing index.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The configuration for the Supabase database.
-     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
-     */
-    static async fromExistingIndex(embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        return instance;
-    }
-}
-exports.SupabaseVectorStore = SupabaseVectorStore;
+__exportStar(require("@langchain/community/vectorstores/supabase"), exports);

package/dist/vectorstores/supabase.d.ts

@@ -1,118 +1 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-import type { PostgrestFilterBuilder } from "@supabase/postgrest-js";
-import { MaxMarginalRelevanceSearchOptions, VectorStore } from "./base.js";
-import { Embeddings } from "../embeddings/base.js";
-import { Document } from "../document.js";
-export type SupabaseMetadata = Record<string, any>;
-export type SupabaseFilter = PostgrestFilterBuilder<any, any, any>;
-export type SupabaseFilterRPCCall = (rpcCall: SupabaseFilter) => SupabaseFilter;
-/**
- * Interface for the response returned when searching embeddings.
- */
-interface SearchEmbeddingsResponse {
-    id: number;
-    content: string;
-    metadata: object;
-    embedding: number[];
-    similarity: number;
-}
-/**
- * Interface for the arguments required to initialize a Supabase library.
- */
-export interface SupabaseLibArgs {
-    client: SupabaseClient;
-    tableName?: string;
-    queryName?: string;
-    filter?: SupabaseMetadata | SupabaseFilterRPCCall;
-    upsertBatchSize?: number;
-}
-/**
- * Class for interacting with a Supabase database to store and manage
- * vectors.
- */
-export declare class SupabaseVectorStore extends VectorStore {
-    FilterType: SupabaseMetadata | SupabaseFilterRPCCall;
-    client: SupabaseClient;
-    tableName: string;
-    queryName: string;
-    filter?: SupabaseMetadata | SupabaseFilterRPCCall;
-    upsertBatchSize: number;
-    _vectorstoreType(): string;
-    constructor(embeddings: Embeddings, args: SupabaseLibArgs);
-    /**
-     * Adds documents to the vector store.
-     * @param documents The documents to add.
-     * @param options Optional parameters for adding the documents.
-     * @returns A promise that resolves when the documents have been added.
-     */
-    addDocuments(documents: Document[], options?: {
-        ids?: string[] | number[];
-    }): Promise<string[]>;
-    /**
-     * Adds vectors to the vector store.
-     * @param vectors The vectors to add.
-     * @param documents The documents associated with the vectors.
-     * @param options Optional parameters for adding the vectors.
-     * @returns A promise that resolves with the IDs of the added vectors when the vectors have been added.
-     */
-    addVectors(vectors: number[][], documents: Document[], options?: {
-        ids?: string[] | number[];
-    }): Promise<string[]>;
-    /**
-     * Deletes vectors from the vector store.
-     * @param params The parameters for deleting vectors.
-     * @returns A promise that resolves when the vectors have been deleted.
-     */
-    delete(params: {
-        ids: string[] | number[];
-    }): Promise<void>;
-    protected _searchSupabase(query: number[], k: number, filter?: this["FilterType"]): Promise<SearchEmbeddingsResponse[]>;
-    /**
-     * Performs a similarity search on the vector store.
-     * @param query The query vector.
-     * @param k The number of results to return.
-     * @param filter Optional filter to apply to the search.
-     * @returns A promise that resolves with the search results when the search is complete.
-     */
-    similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
-    /**
-     * Return documents selected using the maximal marginal relevance.
-     * Maximal marginal relevance optimizes for similarity to the query AND diversity
-     * among selected documents.
-     *
-     * @param {string} query - Text to look up documents similar to.
-     * @param {number} options.k - Number of documents to return.
-     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
-     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
-     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
-     * @param {SupabaseLibArgs} options.filter - Optional filter to apply to the search.
-     *
-     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
-     */
-    maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>): Promise<Document[]>;
-    /**
-     * Creates a new SupabaseVectorStore instance from an array of texts.
-     * @param texts The texts to create documents from.
-     * @param metadatas The metadata for the documents.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The configuration for the Supabase database.
-     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
-     */
-    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
-    /**
-     * Creates a new SupabaseVectorStore instance from an array of documents.
-     * @param docs The documents to create the instance from.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The configuration for the Supabase database.
-     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
-     */
-    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
-    /**
-     * Creates a new SupabaseVectorStore instance from an existing index.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The configuration for the Supabase database.
-     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
-     */
-    static fromExistingIndex(embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
-}
-export {};
+export * from "@langchain/community/vectorstores/supabase";