langchain 0.0.202 → 0.0.204-rc.0

package/dist/vectorstores/pgvector.js

@@ -1,400 +1 @@
-import pg from "pg";
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-import { getEnvironmentVariable } from "../util/env.js";
-/**
- * Class that provides an interface to a Postgres vector database. It
- * extends the `VectorStore` base class and implements methods for adding
- * documents and vectors, performing similarity searches, and ensuring the
- * existence of a table in the database.
- */
-export class PGVectorStore extends VectorStore {
-    _vectorstoreType() {
-        return "pgvector";
-    }
-    constructor(embeddings, config) {
-        super(embeddings, config);
-        Object.defineProperty(this, "tableName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "collectionTableName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "collectionName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "langchain"
-        });
-        Object.defineProperty(this, "collectionMetadata", {
-            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
-        });
-        Object.defineProperty(this, "chunkSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 500
-        });
-        this.tableName = config.tableName;
-        this.collectionTableName = config.collectionTableName;
-        this.collectionName = config.collectionName ?? "langchain";
-        this.collectionMetadata = config.collectionMetadata ?? null;
-        this.filter = config.filter;
-        this.vectorColumnName = config.columns?.vectorColumnName ?? "embedding";
-        this.contentColumnName = config.columns?.contentColumnName ?? "text";
-        this.idColumnName = config.columns?.idColumnName ?? "id";
-        this.metadataColumnName = config.columns?.metadataColumnName ?? "metadata";
-        const pool = new pg.Pool(config.postgresConnectionOptions);
-        this.pool = pool;
-        this.chunkSize = config.chunkSize ?? 500;
-        this._verbose =
-            getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" ??
-                !!config.verbose;
-    }
-    /**
-     * Static method to create a new `PGVectorStore` instance from a
-     * connection. It creates a table if one does not exist, and calls
-     * `connect` to return a new instance of `PGVectorStore`.
-     *
-     * @param embeddings - Embeddings instance.
-     * @param fields - `PGVectorStoreArgs` instance.
-     * @returns A new instance of `PGVectorStore`.
-     */
-    static async initialize(embeddings, config) {
-        const postgresqlVectorStore = new PGVectorStore(embeddings, config);
-        await postgresqlVectorStore._initializeClient();
-        await postgresqlVectorStore.ensureTableInDatabase();
-        if (postgresqlVectorStore.collectionTableName) {
-            await postgresqlVectorStore.ensureCollectionTableInDatabase();
-        }
-        return postgresqlVectorStore;
-    }
-    async _initializeClient() {
-        this.client = await this.pool.connect();
-    }
-    /**
-     * Method to add documents to the vector store. It converts the documents into
-     * vectors, and adds them to the store.
-     *
-     * @param documents - Array of `Document` instances.
-     * @returns Promise that resolves when the documents have been added.
-     */
-    async addDocuments(documents) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
-    }
-    /**
-     * Inserts a row for the collectionName provided at initialization if it does not
-     * exist and returns the collectionId.
-     *
-     * @returns The collectionId for the given collectionName.
-     */
-    async getOrCreateCollection() {
-        const queryString = `
-      SELECT uuid from ${this.collectionTableName}
-      WHERE name = $1;
-    `;
-        const queryResult = await this.pool.query(queryString, [
-            this.collectionName,
-        ]);
-        let collectionId = queryResult.rows[0]?.uuid;
-        if (!collectionId) {
-            const insertString = `
-        INSERT INTO ${this.collectionTableName}(
-          uuid,
-          name,
-          cmetadata
-        )
-        VALUES (
-          uuid_generate_v4(),
-          $1,
-          $2
-        )
-        RETURNING uuid;
-      `;
-            const insertResult = await this.pool.query(insertString, [
-                this.collectionName,
-                this.collectionMetadata,
-            ]);
-            collectionId = insertResult.rows[0]?.uuid;
-        }
-        return collectionId;
-    }
-    /**
-     * 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.
-     * @param numOfColumns - The number of columns we are inserting data into.
-     * @returns The SQL placeholders for the row values.
-     */
-    generatePlaceholderForRowAt(index, numOfColumns) {
-        const placeholders = [];
-        for (let i = 0; i < numOfColumns; i += 1) {
-            placeholders.push(`$${index * numOfColumns + i + 1}`);
-        }
-        return `(${placeholders.join(", ")})`;
-    }
-    /**
-     * 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 buildInsertQuery(rows) {
-        let collectionId;
-        if (this.collectionTableName) {
-            collectionId = await this.getOrCreateCollection();
-        }
-        const columns = [
-            this.contentColumnName,
-            this.vectorColumnName,
-            this.metadataColumnName,
-        ];
-        if (collectionId) {
-            columns.push("collection_id");
-        }
-        const valuesPlaceholders = rows
-            .map((_, j) => this.generatePlaceholderForRowAt(j, columns.length))
-            .join(", ");
-        const text = `
-      INSERT INTO ${this.tableName}(
-        ${columns}
-      )
-      VALUES ${valuesPlaceholders}
-    `;
-        return text;
-    }
-    /**
-     * Method to add vectors to the vector store. It converts the vectors into
-     * rows and inserts them into the database.
-     *
-     * @param vectors - Array of vectors.
-     * @param documents - Array of `Document` instances.
-     * @returns Promise that resolves when the vectors have been added.
-     */
-    async addVectors(vectors, documents) {
-        const rows = [];
-        let collectionId;
-        if (this.collectionTableName) {
-            collectionId = await this.getOrCreateCollection();
-        }
-        for (let i = 0; i < vectors.length; i += 1) {
-            const values = [];
-            const embedding = vectors[i];
-            const embeddingString = `[${embedding.join(",")}]`;
-            values.push(documents[i].pageContent, embeddingString, documents[i].metadata);
-            if (collectionId) {
-                values.push(collectionId);
-            }
-            rows.push(values);
-        }
-        for (let i = 0; i < rows.length; i += this.chunkSize) {
-            const chunk = rows.slice(i, i + this.chunkSize);
-            const insertQuery = await this.buildInsertQuery(chunk);
-            const flatValues = chunk.flat();
-            try {
-                await this.pool.query(insertQuery, flatValues);
-            }
-            catch (e) {
-                console.error(e);
-                throw new Error(`Error inserting: ${e.message}`);
-            }
-        }
-    }
-    /**
-     * 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 ?? "{}";
-        let collectionId;
-        if (this.collectionTableName) {
-            collectionId = await this.getOrCreateCollection();
-        }
-        const parameters = [embeddingString, _filter, k];
-        if (collectionId) {
-            parameters.push(collectionId);
-        }
-        const queryString = `
-      SELECT *, ${this.vectorColumnName} <=> $1 as "_distance"
-      FROM ${this.tableName}
-      WHERE ${this.metadataColumnName}::jsonb @> $2
-      ${collectionId ? "AND collection_id = $4" : ""}
-      ORDER BY "_distance" ASC
-      LIMIT $3;
-    `;
-        const documents = (await this.pool.query(queryString, parameters)).rows;
-        const results = [];
-        for (const doc of documents) {
-            if (doc._distance != null && doc[this.contentColumnName] != null) {
-                const document = new Document({
-                    pageContent: doc[this.contentColumnName],
-                    metadata: doc[this.metadataColumnName],
-                });
-                results.push([document, doc._distance]);
-            }
-        }
-        return results;
-    }
-    /**
-     * Method to ensure the existence of the table in the database. It creates
-     * the table if it does not already exist.
-     *
-     * @returns Promise that resolves when the table has been ensured.
-     */
-    async ensureTableInDatabase() {
-        await this.pool.query("CREATE EXTENSION IF NOT EXISTS vector;");
-        await this.pool.query('CREATE EXTENSION IF NOT EXISTS "uuid-ossp";');
-        await this.pool.query(`
-      CREATE TABLE IF NOT EXISTS ${this.tableName} (
-        "${this.idColumnName}" uuid NOT NULL DEFAULT uuid_generate_v4() PRIMARY KEY,
-        "${this.contentColumnName}" text,
-        "${this.metadataColumnName}" jsonb,
-        "${this.vectorColumnName}" vector
-      );
-    `);
-    }
-    /**
-     * Method to ensure the existence of the collection table in the database.
-     * It creates the table if it does not already exist.
-     *
-     * @returns Promise that resolves when the collection table has been ensured.
-     */
-    async ensureCollectionTableInDatabase() {
-        try {
-            await this.pool.query(`
-        CREATE TABLE IF NOT EXISTS ${this.collectionTableName} (
-          uuid uuid NOT NULL DEFAULT uuid_generate_v4() PRIMARY KEY,
-          name character varying,
-          cmetadata jsonb
-        );
-
-        ALTER TABLE ${this.tableName}
-          ADD COLUMN collection_id uuid;
-
-        ALTER TABLE ${this.tableName}
-          ADD CONSTRAINT ${this.tableName}_collection_id_fkey
-          FOREIGN KEY (collection_id)
-          REFERENCES ${this.collectionTableName}(uuid)
-          ON DELETE CASCADE;
-      `);
-        }
-        catch (e) {
-            if (!e.message.includes("already exists")) {
-                console.error(e);
-                throw new Error(`Error adding column: ${e.message}`);
-            }
-        }
-    }
-    /**
-     * Static method to create a new `PGVectorStore` instance from an
-     * array of texts and their metadata. It converts the texts into
-     * `Document` instances and adds them to the store.
-     *
-     * @param texts - Array of texts.
-     * @param metadatas - Array of metadata objects or a single metadata object.
-     * @param embeddings - Embeddings instance.
-     * @param dbConfig - `PGVectorStoreArgs` instance.
-     * @returns Promise that resolves with a new instance of `PGVectorStore`.
-     */
-    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
-        const docs = [];
-        for (let i = 0; i < texts.length; i += 1) {
-            const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
-            const newDoc = new Document({
-                pageContent: texts[i],
-                metadata,
-            });
-            docs.push(newDoc);
-        }
-        return PGVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Static method to create a new `PGVectorStore` instance from an
-     * array of `Document` instances. It adds the documents to the store.
-     *
-     * @param docs - Array of `Document` instances.
-     * @param embeddings - Embeddings instance.
-     * @param dbConfig - `PGVectorStoreArgs` instance.
-     * @returns Promise that resolves with a new instance of `PGVectorStore`.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = await PGVectorStore.initialize(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Closes all the clients in the pool and terminates the pool.
-     *
-     * @returns Promise that resolves when all clients are closed and the pool is terminated.
-     */
-    async end() {
-        this.client?.release();
-        return this.pool.end();
-    }
-}
+export * from "@langchain/community/vectorstores/pgvector";

package/dist/vectorstores/pinecone.cjs

@@ -10,285 +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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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.PineconeStore = void 0;
-/* eslint-disable no-process-env */
-const uuid = __importStar(require("uuid"));
-const flat_1 = __importDefault(require("flat"));
-const base_js_1 = require("./base.cjs");
-const document_js_1 = require("../document.cjs");
-const async_caller_js_1 = require("../util/async_caller.cjs");
-const math_js_1 = require("../util/math.cjs");
-const chunk_js_1 = require("../util/chunk.cjs");
-/**
- * Class that extends the VectorStore class and provides methods to
- * interact with the Pinecone vector database.
- */
-class PineconeStore extends base_js_1.VectorStore {
-    _vectorstoreType() {
-        return "pinecone";
-    }
-    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, "pineconeIndex", {
-            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, "caller", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.embeddings = embeddings;
-        const { namespace, pineconeIndex, textKey, filter, ...asyncCallerArgs } = args;
-        this.namespace = namespace;
-        this.pineconeIndex = pineconeIndex;
-        this.textKey = textKey ?? "text";
-        this.filter = filter;
-        this.caller = new async_caller_js_1.AsyncCaller(asyncCallerArgs);
-    }
-    /**
-     * Method that adds documents to the Pinecone database.
-     * @param documents Array of documents to add to the Pinecone database.
-     * @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 Pinecone database.
-     * @param vectors Array of vectors to add to the Pinecone database.
-     * @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 pineconeVectors = vectors.map((values, idx) => {
-            // Pinecone doesn't support nested objects, so we flatten them
-            const documentMetadata = { ...documents[idx].metadata };
-            // preserve string arrays which are allowed
-            const stringArrays = {};
-            for (const key of Object.keys(documentMetadata)) {
-                if (Array.isArray(documentMetadata[key]) &&
-                    // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any
-                    documentMetadata[key].every((el) => typeof el === "string")) {
-                    stringArrays[key] = documentMetadata[key];
-                    delete documentMetadata[key];
-                }
-            }
-            const metadata = {
-                ...(0, flat_1.default)(documentMetadata),
-                ...stringArrays,
-                [this.textKey]: documents[idx].pageContent,
-            };
-            // Pinecone doesn't support null values, so we remove them
-            for (const key of Object.keys(metadata)) {
-                if (metadata[key] == null) {
-                    delete metadata[key];
-                }
-                else if (typeof metadata[key] === "object" &&
-                    Object.keys(metadata[key]).length === 0) {
-                    delete metadata[key];
-                }
-            }
-            return {
-                id: documentIds[idx],
-                metadata,
-                values,
-            };
-        });
-        const namespace = this.pineconeIndex.namespace(this.namespace ?? "");
-        // Pinecone recommends a limit of 100 vectors per upsert request
-        const chunkSize = 100;
-        const chunkedVectors = (0, chunk_js_1.chunkArray)(pineconeVectors, chunkSize);
-        const batchRequests = chunkedVectors.map((chunk) => this.caller.call(async () => namespace.upsert(chunk)));
-        await Promise.all(batchRequests);
-        return documentIds;
-    }
-    /**
-     * Method that deletes vectors from the Pinecone database.
-     * @param params Parameters for the delete operation.
-     * @returns Promise that resolves when the delete operation is complete.
-     */
-    async delete(params) {
-        const { deleteAll, ids, filter } = params;
-        const namespace = this.pineconeIndex.namespace(this.namespace ?? "");
-        if (deleteAll) {
-            await namespace.deleteAll();
-        }
-        else if (ids) {
-            const batchSize = 1000;
-            for (let i = 0; i < ids.length; i += batchSize) {
-                const batchIds = ids.slice(i, i + batchSize);
-                await namespace.deleteMany(batchIds);
-            }
-        }
-        else if (filter) {
-            await namespace.deleteMany(filter);
-        }
-        else {
-            throw new Error("Either ids or delete_all must be provided.");
-        }
-    }
-    async _runPineconeQuery(query, k, filter, options) {
-        if (filter && this.filter) {
-            throw new Error("cannot provide both `filter` and `this.filter`");
-        }
-        const _filter = filter ?? this.filter;
-        const namespace = this.pineconeIndex.namespace(this.namespace ?? "");
-        const results = await namespace.query({
-            includeMetadata: true,
-            topK: k,
-            vector: query,
-            filter: _filter,
-            ...options,
-        });
-        return results;
-    }
-    /**
-     * Method that performs a similarity search in the Pinecone 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.
-     * @param filter Optional filter to apply to the search.
-     * @returns Promise that resolves with an array of documents and their scores.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        const results = await this._runPineconeQuery(query, k, filter);
-        const result = [];
-        if (results.matches) {
-            for (const res of results.matches) {
-                const { [this.textKey]: pageContent, ...metadata } = (res.metadata ??
-                    {});
-                if (res.score) {
-                    result.push([new document_js_1.Document({ metadata, pageContent }), res.score]);
-                }
-            }
-        }
-        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 {PineconeMetadata} 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 results = await this._runPineconeQuery(queryEmbedding, options.fetchK ?? 20, options.filter, { includeValues: true });
-        const matches = results?.matches ?? [];
-        const embeddingList = matches.map((match) => match.values);
-        const mmrIndexes = (0, math_js_1.maximalMarginalRelevance)(queryEmbedding, embeddingList, options.lambda, options.k);
-        const topMmrMatches = mmrIndexes.map((idx) => matches[idx]);
-        const finalResult = [];
-        for (const res of topMmrMatches) {
-            const { [this.textKey]: pageContent, ...metadata } = (res.metadata ??
-                {});
-            if (res.score) {
-                finalResult.push(new document_js_1.Document({ metadata, pageContent }));
-            }
-        }
-        return finalResult;
-    }
-    /**
-     * Static method that creates a new instance of the PineconeStore class
-     * from texts.
-     * @param texts Array of texts to add to the Pinecone database.
-     * @param metadatas Metadata associated with the texts.
-     * @param embeddings Embeddings to use for the texts.
-     * @param dbConfig Configuration for the Pinecone database.
-     * @returns Promise that resolves with a new instance of the PineconeStore 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_js_1.Document({
-                pageContent: texts[i],
-                metadata,
-            });
-            docs.push(newDoc);
-        }
-        const args = {
-            pineconeIndex: dbConfig.pineconeIndex,
-            textKey: dbConfig.textKey,
-            namespace: dbConfig.namespace,
-        };
-        return PineconeStore.fromDocuments(docs, embeddings, args);
-    }
-    /**
-     * Static method that creates a new instance of the PineconeStore class
-     * from documents.
-     * @param docs Array of documents to add to the Pinecone database.
-     * @param embeddings Embeddings to use for the documents.
-     * @param dbConfig Configuration for the Pinecone database.
-     * @returns Promise that resolves with a new instance of the PineconeStore class.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const args = dbConfig;
-        args.textKey = dbConfig.textKey ?? "text";
-        const instance = new this(embeddings, args);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Static method that creates a new instance of the PineconeStore class
-     * from an existing index.
-     * @param embeddings Embeddings to use for the documents.
-     * @param dbConfig Configuration for the Pinecone database.
-     * @returns Promise that resolves with a new instance of the PineconeStore class.
-     */
-    static async fromExistingIndex(embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        return instance;
-    }
-}
-exports.PineconeStore = PineconeStore;
+__exportStar(require("@langchain/community/vectorstores/pinecone"), exports);