langchain 0.0.203 → 0.0.204-rc.1

package/dist/vectorstores/supabase.js

@@ -1,215 +1 @@
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-import { maximalMarginalRelevance } from "../util/math.js";
-/**
- * Class for interacting with a Supabase database to store and manage
- * vectors.
- */
-export class SupabaseVectorStore extends 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({
-                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 = maximalMarginalRelevance(queryEmbedding, embeddingList, options.lambda, options.k);
-        return mmrIndexes.map((idx) => new 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({
-                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;
-    }
-}
+export * from "@langchain/community/vectorstores/supabase";

package/dist/vectorstores/tigris.cjs

@@ -10,148 +10,8 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+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.TigrisVectorStore = void 0;
-const uuid = __importStar(require("uuid"));
-const base_js_1 = require("./base.cjs");
-const document_js_1 = require("../document.cjs");
-/**
- * Class for managing and operating vector search applications with
- * Tigris, an open-source Serverless NoSQL Database and Search Platform.
- */
-class TigrisVectorStore extends base_js_1.VectorStore {
-    _vectorstoreType() {
-        return "tigris";
-    }
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Object.defineProperty(this, "index", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.embeddings = embeddings;
-        this.index = args.index;
-    }
-    /**
-     * Method to add an array of documents to the Tigris database.
-     * @param documents An array of Document instances to be added to the Tigris database.
-     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
-     * @returns A Promise that resolves when the documents have been added to the Tigris database.
-     */
-    async addDocuments(documents, options) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
-    }
-    /**
-     * Method to add vectors to the Tigris database.
-     * @param vectors An array of vectors to be added to the Tigris database.
-     * @param documents An array of Document instances corresponding to the vectors.
-     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
-     * @returns A Promise that resolves when the vectors have been added to the Tigris database.
-     */
-    async addVectors(vectors, documents, options) {
-        if (vectors.length === 0) {
-            return;
-        }
-        if (vectors.length !== documents.length) {
-            throw new Error(`Vectors and metadatas must have the same length`);
-        }
-        const ids = Array.isArray(options) ? options : options?.ids;
-        const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
-        await this.index?.addDocumentsWithVectors({
-            ids: documentIds,
-            embeddings: vectors,
-            documents: documents.map(({ metadata, pageContent }) => ({
-                content: pageContent,
-                metadata,
-            })),
-        });
-    }
-    /**
-     * Method to perform a similarity search in the Tigris database and return
-     * the k most similar vectors along with their similarity scores.
-     * @param query The query vector.
-     * @param k The number of most similar vectors to return.
-     * @param filter Optional filter object to apply during the search.
-     * @returns A Promise that resolves to an array of tuples, each containing a Document and its similarity score.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        const result = await this.index?.similaritySearchVectorWithScore({
-            query,
-            k,
-            filter,
-        });
-        if (!result) {
-            return [];
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return result.map(([document, score]) => [
-            new document_js_1.Document({
-                pageContent: document.content,
-                metadata: document.metadata,
-            }),
-            score,
-        ]);
-    }
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * array of texts.
-     * @param texts An array of texts to be converted into Document instances and added to the Tigris database.
-     * @param metadatas Either an array of metadata objects or a single metadata object to be associated with the texts.
-     * @param embeddings An instance of Embeddings to be used for embedding the texts.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    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 TigrisVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * array of Document instances.
-     * @param docs An array of Document instances to be added to the Tigris database.
-     * @param embeddings An instance of Embeddings to be used for embedding the documents.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * existing index.
-     * @param embeddings An instance of Embeddings to be used for embedding the documents.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    static async fromExistingIndex(embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        return instance;
-    }
-}
-exports.TigrisVectorStore = TigrisVectorStore;
+__exportStar(require("@langchain/community/vectorstores/tigris"), exports);

package/dist/vectorstores/tigris.d.ts

@@ -1,74 +1 @@
-import { Embeddings } from "../embeddings/base.js";
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-/**
- * Type definition for the arguments required to initialize a
- * TigrisVectorStore instance.
- */
-export type TigrisLibArgs = {
-    index: any;
-};
-/**
- * Class for managing and operating vector search applications with
- * Tigris, an open-source Serverless NoSQL Database and Search Platform.
- */
-export declare class TigrisVectorStore extends VectorStore {
-    index?: any;
-    _vectorstoreType(): string;
-    constructor(embeddings: Embeddings, args: TigrisLibArgs);
-    /**
-     * Method to add an array of documents to the Tigris database.
-     * @param documents An array of Document instances to be added to the Tigris database.
-     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
-     * @returns A Promise that resolves when the documents have been added to the Tigris database.
-     */
-    addDocuments(documents: Document[], options?: {
-        ids?: string[];
-    } | string[]): Promise<void>;
-    /**
-     * Method to add vectors to the Tigris database.
-     * @param vectors An array of vectors to be added to the Tigris database.
-     * @param documents An array of Document instances corresponding to the vectors.
-     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
-     * @returns A Promise that resolves when the vectors have been added to the Tigris database.
-     */
-    addVectors(vectors: number[][], documents: Document[], options?: {
-        ids?: string[];
-    } | string[]): Promise<void>;
-    /**
-     * Method to perform a similarity search in the Tigris database and return
-     * the k most similar vectors along with their similarity scores.
-     * @param query The query vector.
-     * @param k The number of most similar vectors to return.
-     * @param filter Optional filter object to apply during the search.
-     * @returns A Promise that resolves to an array of tuples, each containing a Document and its similarity score.
-     */
-    similaritySearchVectorWithScore(query: number[], k: number, filter?: object): Promise<[Document<Record<string, any>>, number][]>;
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * array of texts.
-     * @param texts An array of texts to be converted into Document instances and added to the Tigris database.
-     * @param metadatas Either an array of metadata objects or a single metadata object to be associated with the texts.
-     * @param embeddings An instance of Embeddings to be used for embedding the texts.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * array of Document instances.
-     * @param docs An array of Document instances to be added to the Tigris database.
-     * @param embeddings An instance of Embeddings to be used for embedding the documents.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * existing index.
-     * @param embeddings An instance of Embeddings to be used for embedding the documents.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    static fromExistingIndex(embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;
-}
+export * from "@langchain/community/vectorstores/tigris";

package/dist/vectorstores/tigris.js

@@ -1,130 +1 @@
-import * as uuid from "uuid";
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-/**
- * Class for managing and operating vector search applications with
- * Tigris, an open-source Serverless NoSQL Database and Search Platform.
- */
-export class TigrisVectorStore extends VectorStore {
-    _vectorstoreType() {
-        return "tigris";
-    }
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Object.defineProperty(this, "index", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.embeddings = embeddings;
-        this.index = args.index;
-    }
-    /**
-     * Method to add an array of documents to the Tigris database.
-     * @param documents An array of Document instances to be added to the Tigris database.
-     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
-     * @returns A Promise that resolves when the documents have been added to the Tigris database.
-     */
-    async addDocuments(documents, options) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
-    }
-    /**
-     * Method to add vectors to the Tigris database.
-     * @param vectors An array of vectors to be added to the Tigris database.
-     * @param documents An array of Document instances corresponding to the vectors.
-     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
-     * @returns A Promise that resolves when the vectors have been added to the Tigris database.
-     */
-    async addVectors(vectors, documents, options) {
-        if (vectors.length === 0) {
-            return;
-        }
-        if (vectors.length !== documents.length) {
-            throw new Error(`Vectors and metadatas must have the same length`);
-        }
-        const ids = Array.isArray(options) ? options : options?.ids;
-        const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
-        await this.index?.addDocumentsWithVectors({
-            ids: documentIds,
-            embeddings: vectors,
-            documents: documents.map(({ metadata, pageContent }) => ({
-                content: pageContent,
-                metadata,
-            })),
-        });
-    }
-    /**
-     * Method to perform a similarity search in the Tigris database and return
-     * the k most similar vectors along with their similarity scores.
-     * @param query The query vector.
-     * @param k The number of most similar vectors to return.
-     * @param filter Optional filter object to apply during the search.
-     * @returns A Promise that resolves to an array of tuples, each containing a Document and its similarity score.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        const result = await this.index?.similaritySearchVectorWithScore({
-            query,
-            k,
-            filter,
-        });
-        if (!result) {
-            return [];
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return result.map(([document, score]) => [
-            new Document({
-                pageContent: document.content,
-                metadata: document.metadata,
-            }),
-            score,
-        ]);
-    }
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * array of texts.
-     * @param texts An array of texts to be converted into Document instances and added to the Tigris database.
-     * @param metadatas Either an array of metadata objects or a single metadata object to be associated with the texts.
-     * @param embeddings An instance of Embeddings to be used for embedding the texts.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    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 TigrisVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * array of Document instances.
-     * @param docs An array of Document instances to be added to the Tigris database.
-     * @param embeddings An instance of Embeddings to be used for embedding the documents.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Static method to create a new instance of TigrisVectorStore from an
-     * existing index.
-     * @param embeddings An instance of Embeddings to be used for embedding the documents.
-     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
-     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
-     */
-    static async fromExistingIndex(embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        return instance;
-    }
-}
+export * from "@langchain/community/vectorstores/tigris";