langchain 0.0.197-rc.1 → 0.0.198

package/dist/document_loaders/fs/openai_whisper_audio.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIWhisperAudio = void 0;
-const openai_1 = require("@langchain/openai");
+const openai_1 = require("openai");
 const document_js_1 = require("../../document.cjs");
 const buffer_js_1 = require("./buffer.cjs");
 const MODEL_NAME = "whisper-1";
@@ -24,7 +24,7 @@ class OpenAIWhisperAudio extends buffer_js_1.BufferLoader {
             writable: true,
             value: void 0
         });
-        this.openAIClient = new openai_1.OpenAIClient(fields?.clientOptions);
+        this.openAIClient = new openai_1.OpenAI(fields?.clientOptions);
     }
     async parse(raw, metadata) {
         const fileName = metadata.source === "blob" ? metadata.blobType : metadata.source;

package/dist/document_loaders/fs/openai_whisper_audio.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-import { type ClientOptions } from "@langchain/openai";
+import { type ClientOptions } from "openai";
 import { Document } from "../../document.js";
 import { BufferLoader } from "./buffer.js";
 /**

package/dist/document_loaders/fs/openai_whisper_audio.js

@@ -1,4 +1,4 @@
-import { OpenAIClient, toFile } from "@langchain/openai";
+import { OpenAI as OpenAIClient, toFile } from "openai";
 import { Document } from "../../document.js";
 import { BufferLoader } from "./buffer.js";
 const MODEL_NAME = "whisper-1";

package/dist/document_loaders/fs/pptx.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PPTXLoader = void 0;
+const officeparser_1 = require("officeparser");
+const document_js_1 = require("../../document.cjs");
+const buffer_js_1 = require("./buffer.cjs");
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
+class PPTXLoader extends buffer_js_1.BufferLoader {
+    constructor(filePathOrBlob) {
+        super(filePathOrBlob);
+    }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `parseOfficeAsync` function from the `officeparser` module to extract
+     * the raw text content from the buffer. If the extracted powerpoint content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted powerpoint content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
+    async parse(raw, metadata) {
+        const pptx = await (0, officeparser_1.parseOfficeAsync)(raw, { outputErrorToConsole: true });
+        if (!pptx)
+            return [];
+        return [
+            new document_js_1.Document({
+                pageContent: pptx,
+                metadata,
+            }),
+        ];
+    }
+}
+exports.PPTXLoader = PPTXLoader;

package/dist/document_loaders/fs/pptx.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Document } from "../../document.js";
+import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
+export declare class PPTXLoader extends BufferLoader {
+    constructor(filePathOrBlob: string | Blob);
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `parseOfficeAsync` function from the `officeparser` module to extract
+     * the raw text content from the buffer. If the extracted powerpoint content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted powerpoint content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
+    parse(raw: Buffer, metadata: Document["metadata"]): Promise<Document[]>;
+}

package/dist/document_loaders/fs/pptx.js

@@ -0,0 +1,35 @@
+import { parseOfficeAsync } from "officeparser";
+import { Document } from "../../document.js";
+import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
+export class PPTXLoader extends BufferLoader {
+    constructor(filePathOrBlob) {
+        super(filePathOrBlob);
+    }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `parseOfficeAsync` function from the `officeparser` module to extract
+     * the raw text content from the buffer. If the extracted powerpoint content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted powerpoint content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
+    async parse(raw, metadata) {
+        const pptx = await parseOfficeAsync(raw, { outputErrorToConsole: true });
+        if (!pptx)
+            return [];
+        return [
+            new Document({
+                pageContent: pptx,
+                metadata,
+            }),
+        ];
+    }
+}

package/dist/embeddings/openai.cjs

@@ -1,5 +1,243 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIEmbeddings = void 0;
-var openai_1 = require("@langchain/openai");
-Object.defineProperty(exports, "OpenAIEmbeddings", { enumerable: true, get: function () { return openai_1.OpenAIEmbeddings; } });
+const openai_1 = require("openai");
+const env_js_1 = require("../util/env.cjs");
+const chunk_js_1 = require("../util/chunk.cjs");
+const base_js_1 = require("./base.cjs");
+const azure_js_1 = require("../util/azure.cjs");
+const openai_js_1 = require("../util/openai.cjs");
+/**
+ * Class for generating embeddings using the OpenAI API. Extends the
+ * Embeddings class and implements OpenAIEmbeddingsParams and
+ * AzureOpenAIInput.
+ * @example
+ * ```typescript
+ * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text
+ * const model = new OpenAIEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?",
+ * );
+ * console.log({ res });
+ *
+ * ```
+ */
+class OpenAIEmbeddings extends base_js_1.Embeddings {
+    constructor(fields, configuration) {
+        const fieldsWithDefaults = { maxConcurrency: 2, ...fields };
+        super(fieldsWithDefaults);
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text-embedding-ada-002"
+        });
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 512
+        });
+        Object.defineProperty(this, "stripNewLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiVersion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiInstanceName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiDeploymentName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIBasePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "organization", {
+            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, "clientConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        let apiKey = fieldsWithDefaults?.openAIApiKey ??
+            (0, env_js_1.getEnvironmentVariable)("OPENAI_API_KEY");
+        const azureApiKey = fieldsWithDefaults?.azureOpenAIApiKey ??
+            (0, env_js_1.getEnvironmentVariable)("AZURE_OPENAI_API_KEY");
+        if (!azureApiKey && !apiKey) {
+            throw new Error("OpenAI or Azure OpenAI API key not found");
+        }
+        const azureApiInstanceName = fieldsWithDefaults?.azureOpenAIApiInstanceName ??
+            (0, env_js_1.getEnvironmentVariable)("AZURE_OPENAI_API_INSTANCE_NAME");
+        const azureApiDeploymentName = (fieldsWithDefaults?.azureOpenAIApiEmbeddingsDeploymentName ||
+            fieldsWithDefaults?.azureOpenAIApiDeploymentName) ??
+            ((0, env_js_1.getEnvironmentVariable)("AZURE_OPENAI_API_EMBEDDINGS_DEPLOYMENT_NAME") ||
+                (0, env_js_1.getEnvironmentVariable)("AZURE_OPENAI_API_DEPLOYMENT_NAME"));
+        const azureApiVersion = fieldsWithDefaults?.azureOpenAIApiVersion ??
+            (0, env_js_1.getEnvironmentVariable)("AZURE_OPENAI_API_VERSION");
+        this.azureOpenAIBasePath =
+            fieldsWithDefaults?.azureOpenAIBasePath ??
+                (0, env_js_1.getEnvironmentVariable)("AZURE_OPENAI_BASE_PATH");
+        this.organization =
+            fieldsWithDefaults?.configuration?.organization ??
+                (0, env_js_1.getEnvironmentVariable)("OPENAI_ORGANIZATION");
+        this.modelName = fieldsWithDefaults?.modelName ?? this.modelName;
+        this.batchSize =
+            fieldsWithDefaults?.batchSize ?? (azureApiKey ? 1 : this.batchSize);
+        this.stripNewLines =
+            fieldsWithDefaults?.stripNewLines ?? this.stripNewLines;
+        this.timeout = fieldsWithDefaults?.timeout;
+        this.azureOpenAIApiVersion = azureApiVersion;
+        this.azureOpenAIApiKey = azureApiKey;
+        this.azureOpenAIApiInstanceName = azureApiInstanceName;
+        this.azureOpenAIApiDeploymentName = azureApiDeploymentName;
+        if (this.azureOpenAIApiKey) {
+            if (!this.azureOpenAIApiInstanceName && !this.azureOpenAIBasePath) {
+                throw new Error("Azure OpenAI API instance name not found");
+            }
+            if (!this.azureOpenAIApiDeploymentName) {
+                throw new Error("Azure OpenAI API deployment name not found");
+            }
+            if (!this.azureOpenAIApiVersion) {
+                throw new Error("Azure OpenAI API version not found");
+            }
+            apiKey = apiKey ?? "";
+        }
+        this.clientConfig = {
+            apiKey,
+            organization: this.organization,
+            baseURL: configuration?.basePath,
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: configuration?.baseOptions?.headers,
+            defaultQuery: configuration?.baseOptions?.params,
+            ...configuration,
+            ...fields?.configuration,
+        };
+    }
+    /**
+     * Method to generate embeddings for an array of documents. Splits the
+     * documents into batches and makes requests to the OpenAI API to generate
+     * embeddings.
+     * @param texts Array of documents to generate embeddings for.
+     * @returns Promise that resolves to a 2D array of embeddings for each document.
+     */
+    async embedDocuments(texts) {
+        const batches = (0, chunk_js_1.chunkArray)(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
+        const batchRequests = batches.map((batch) => this.embeddingWithRetry({
+            model: this.modelName,
+            input: batch,
+        }));
+        const batchResponses = await Promise.all(batchRequests);
+        const embeddings = [];
+        for (let i = 0; i < batchResponses.length; i += 1) {
+            const batch = batches[i];
+            const { data: batchResponse } = batchResponses[i];
+            for (let j = 0; j < batch.length; j += 1) {
+                embeddings.push(batchResponse[j].embedding);
+            }
+        }
+        return embeddings;
+    }
+    /**
+     * Method to generate an embedding for a single document. Calls the
+     * embeddingWithRetry method with the document as the input.
+     * @param text Document to generate an embedding for.
+     * @returns Promise that resolves to an embedding for the document.
+     */
+    async embedQuery(text) {
+        const { data } = await this.embeddingWithRetry({
+            model: this.modelName,
+            input: this.stripNewLines ? text.replace(/\n/g, " ") : text,
+        });
+        return data[0].embedding;
+    }
+    /**
+     * Private method to make a request to the OpenAI API to generate
+     * embeddings. Handles the retry logic and returns the response from the
+     * API.
+     * @param request Request to send to the OpenAI API.
+     * @returns Promise that resolves to the response from the API.
+     */
+    async embeddingWithRetry(request) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = (0, azure_js_1.getEndpoint)(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new openai_1.OpenAI(params);
+        }
+        const requestOptions = {};
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return this.caller.call(async () => {
+            try {
+                const res = await this.client.embeddings.create(request, requestOptions);
+                return res;
+            }
+            catch (e) {
+                const error = (0, openai_js_1.wrapOpenAIClientError)(e);
+                throw error;
+            }
+        });
+    }
+}
+exports.OpenAIEmbeddings = OpenAIEmbeddings;

package/dist/embeddings/openai.d.ts

@@ -1 +1,82 @@
-export { type OpenAIEmbeddingsParams, OpenAIEmbeddings, } from "@langchain/openai";
+import { type ClientOptions } from "openai";
+import { AzureOpenAIInput, LegacyOpenAIInput } from "../types/openai-types.js";
+import { Embeddings, EmbeddingsParams } from "./base.js";
+/**
+ * Interface for OpenAIEmbeddings parameters. Extends EmbeddingsParams and
+ * defines additional parameters specific to the OpenAIEmbeddings class.
+ */
+export interface OpenAIEmbeddingsParams extends EmbeddingsParams {
+    /** Model name to use */
+    modelName: string;
+    /**
+     * Timeout to use when making requests to OpenAI.
+     */
+    timeout?: number;
+    /**
+     * The maximum number of documents to embed in a single request. This is
+     * limited by the OpenAI API to a maximum of 2048.
+     */
+    batchSize?: number;
+    /**
+     * Whether to strip new lines from the input text. This is recommended by
+     * OpenAI, but may not be suitable for all use cases.
+     */
+    stripNewLines?: boolean;
+}
+/**
+ * Class for generating embeddings using the OpenAI API. Extends the
+ * Embeddings class and implements OpenAIEmbeddingsParams and
+ * AzureOpenAIInput.
+ * @example
+ * ```typescript
+ * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text
+ * const model = new OpenAIEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?",
+ * );
+ * console.log({ res });
+ *
+ * ```
+ */
+export declare class OpenAIEmbeddings extends Embeddings implements OpenAIEmbeddingsParams, AzureOpenAIInput {
+    modelName: string;
+    batchSize: number;
+    stripNewLines: boolean;
+    timeout?: number;
+    azureOpenAIApiVersion?: string;
+    azureOpenAIApiKey?: string;
+    azureOpenAIApiInstanceName?: string;
+    azureOpenAIApiDeploymentName?: string;
+    azureOpenAIBasePath?: string;
+    organization?: string;
+    private client;
+    private clientConfig;
+    constructor(fields?: Partial<OpenAIEmbeddingsParams> & Partial<AzureOpenAIInput> & {
+        verbose?: boolean;
+        openAIApiKey?: string;
+        configuration?: ClientOptions;
+    }, configuration?: ClientOptions & LegacyOpenAIInput);
+    /**
+     * Method to generate embeddings for an array of documents. Splits the
+     * documents into batches and makes requests to the OpenAI API to generate
+     * embeddings.
+     * @param texts Array of documents to generate embeddings for.
+     * @returns Promise that resolves to a 2D array of embeddings for each document.
+     */
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    /**
+     * Method to generate an embedding for a single document. Calls the
+     * embeddingWithRetry method with the document as the input.
+     * @param text Document to generate an embedding for.
+     * @returns Promise that resolves to an embedding for the document.
+     */
+    embedQuery(text: string): Promise<number[]>;
+    /**
+     * Private method to make a request to the OpenAI API to generate
+     * embeddings. Handles the retry logic and returns the response from the
+     * API.
+     * @param request Request to send to the OpenAI API.
+     * @returns Promise that resolves to the response from the API.
+     */
+    private embeddingWithRetry;
+}