langchain 0.0.136 → 0.0.138

package/dist/embeddings/minimax.d.ts

@@ -0,0 +1,104 @@
+import { Embeddings, EmbeddingsParams } from "./base.js";
+import { ConfigurationParameters } from "../chat_models/minimax.js";
+/**
+ * Interface for MinimaxEmbeddings parameters. Extends EmbeddingsParams and
+ * defines additional parameters specific to the MinimaxEmbeddings class.
+ */
+export interface MinimaxEmbeddingsParams extends EmbeddingsParams {
+    /** Model name to use */
+    modelName: string;
+    /**
+     * API key to use when making requests. Defaults to the value of
+     * `MINIMAX_GROUP_ID` environment variable.
+     */
+    minimaxGroupId?: string;
+    /**
+     * Secret key to use when making requests. Defaults to the value of
+     * `MINIMAX_API_KEY` environment variable.
+     */
+    minimaxApiKey?: string;
+    /**
+     * The maximum number of documents to embed in a single request. This is
+     * limited by the Minimax API to a maximum of 4096.
+     */
+    batchSize?: number;
+    /**
+     * Whether to strip new lines from the input text. This is recommended by
+     * Minimax, but may not be suitable for all use cases.
+     */
+    stripNewLines?: boolean;
+    /**
+     *  The target use-case after generating the vector.
+     *  When using embeddings, the vector of the target content is first generated through the db and stored in the vector database,
+     *  and then the vector of the retrieval text is generated through the query.
+     *  Note: For the parameters of the partial algorithm, we adopted a separate algorithm plan for query and db.
+     *  Therefore, for a paragraph of text, if it is to be used as a retrieval text, it should use the db,
+     *  and if it is used as a retrieval text, it should use the query.
+     */
+    type?: "db" | "query";
+}
+export interface CreateMinimaxEmbeddingRequest {
+    /**
+     * @type {string}
+     * @memberof CreateMinimaxEmbeddingRequest
+     */
+    model: string;
+    /**
+     *  Text to generate vector expectation
+     * @type {CreateEmbeddingRequestInput}
+     * @memberof CreateMinimaxEmbeddingRequest
+     */
+    texts: string[];
+    /**
+     *  The target use-case after generating the vector. When using embeddings,
+     *  first generate the vector of the target content through the db and store it in the vector database,
+     *  and then generate the vector of the retrieval text through the query.
+     *  Note: For the parameter of the algorithm, we use the algorithm scheme of query and db separation,
+     *  so a text, if it is to be retrieved as a text, should use the db,
+     *  if it is used as a retrieval text, should use the query.
+     * @type {string}
+     * @memberof CreateMinimaxEmbeddingRequest
+     */
+    type: "db" | "query";
+}
+/**
+ * Class for generating embeddings using the Minimax API. Extends the
+ * Embeddings class and implements MinimaxEmbeddingsParams
+ */
+export declare class MinimaxEmbeddings extends Embeddings implements MinimaxEmbeddingsParams {
+    modelName: string;
+    batchSize: number;
+    stripNewLines: boolean;
+    minimaxGroupId?: string;
+    minimaxApiKey?: string;
+    type: "db" | "query";
+    apiUrl: string;
+    basePath?: string;
+    headers?: Record<string, string>;
+    constructor(fields?: Partial<MinimaxEmbeddingsParams> & {
+        configuration?: ConfigurationParameters;
+    });
+    /**
+     * Method to generate embeddings for an array of documents. Splits the
+     * documents into batches and makes requests to the Minimax 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 Minimax API to generate
+     * embeddings. Handles the retry logic and returns the response from the
+     * API.
+     * @param request Request to send to the Minimax API.
+     * @returns Promise that resolves to the response from the API.
+     */
+    private embeddingWithRetry;
+}

package/dist/embeddings/minimax.js

@@ -0,0 +1,148 @@
+import { getEnvironmentVariable } from "../util/env.js";
+import { chunkArray } from "../util/chunk.js";
+import { Embeddings } from "./base.js";
+/**
+ * Class for generating embeddings using the Minimax API. Extends the
+ * Embeddings class and implements MinimaxEmbeddingsParams
+ */
+export class MinimaxEmbeddings extends Embeddings {
+    constructor(fields) {
+        const fieldsWithDefaults = { maxConcurrency: 2, ...fields };
+        super(fieldsWithDefaults);
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "embo-01"
+        });
+        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, "minimaxGroupId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "minimaxApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "db"
+        });
+        Object.defineProperty(this, "apiUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "basePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "https://api.minimax.chat/v1"
+        });
+        Object.defineProperty(this, "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.minimaxGroupId =
+            fields?.minimaxGroupId ?? getEnvironmentVariable("MINIMAX_GROUP_ID");
+        if (!this.minimaxGroupId) {
+            throw new Error("Minimax GroupID  not found");
+        }
+        this.minimaxApiKey =
+            fields?.minimaxApiKey ?? getEnvironmentVariable("MINIMAX_API_KEY");
+        if (!this.minimaxApiKey) {
+            throw new Error("Minimax ApiKey not found");
+        }
+        this.modelName = fieldsWithDefaults?.modelName ?? this.modelName;
+        this.batchSize = fieldsWithDefaults?.batchSize ?? this.batchSize;
+        this.type = fieldsWithDefaults?.type ?? this.type;
+        this.stripNewLines =
+            fieldsWithDefaults?.stripNewLines ?? this.stripNewLines;
+        this.apiUrl = `${this.basePath}/embeddings`;
+        this.basePath = fields?.configuration?.basePath ?? this.basePath;
+        this.headers = fields?.configuration?.headers ?? this.headers;
+    }
+    /**
+     * Method to generate embeddings for an array of documents. Splits the
+     * documents into batches and makes requests to the Minimax 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 = chunkArray(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
+        const batchRequests = batches.map((batch) => this.embeddingWithRetry({
+            model: this.modelName,
+            texts: batch,
+            type: this.type,
+        }));
+        const batchResponses = await Promise.all(batchRequests);
+        const embeddings = [];
+        for (let i = 0; i < batchResponses.length; i += 1) {
+            const batch = batches[i];
+            const { vectors: batchResponse } = batchResponses[i];
+            for (let j = 0; j < batch.length; j += 1) {
+                embeddings.push(batchResponse[j]);
+            }
+        }
+        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 { vectors } = await this.embeddingWithRetry({
+            model: this.modelName,
+            texts: [this.stripNewLines ? text.replace(/\n/g, " ") : text],
+            type: this.type,
+        });
+        return vectors[0];
+    }
+    /**
+     * Private method to make a request to the Minimax API to generate
+     * embeddings. Handles the retry logic and returns the response from the
+     * API.
+     * @param request Request to send to the Minimax API.
+     * @returns Promise that resolves to the response from the API.
+     */
+    async embeddingWithRetry(request) {
+        const makeCompletionRequest = async () => {
+            const url = `${this.apiUrl}?GroupId=${this.minimaxGroupId}`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.minimaxApiKey}`,
+                    ...this.headers,
+                },
+                body: JSON.stringify(request),
+            });
+            const json = await response.json();
+            return json;
+        };
+        return this.caller.call(makeCompletionRequest);
+    }
+}

package/dist/llms/llama_cpp.cjs

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlamaCpp = void 0;
+const node_llama_cpp_1 = require("node-llama-cpp");
+const base_js_1 = require("./base.cjs");
+/**
+ *  To use this model you need to have the `node-llama-cpp` module installed.
+ *  This can be installed using `npm install -S node-llama-cpp` and the minimum
+ *  version supported in version 2.0.0.
+ *  This also requires that have a locally built version of Llama2 installed.
+ */
+class LlamaCpp extends base_js_1.LLM {
+    static lc_name() {
+        return "LlamaCpp";
+    }
+    constructor(inputs) {
+        super(inputs);
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contextSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embedding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "f16Kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gpuLayers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logitsAll", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lowVram", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "seed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useMlock", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useMmap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vocabOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.batchSize = inputs.batchSize;
+        this.contextSize = inputs.contextSize;
+        this.embedding = inputs.embedding;
+        this.f16Kv = inputs.f16Kv;
+        this.gpuLayers = inputs.gpuLayers;
+        this.logitsAll = inputs.logitsAll;
+        this.lowVram = inputs.lowVram;
+        this.modelPath = inputs.modelPath;
+        this.seed = inputs.seed;
+        this.useMlock = inputs.useMlock;
+        this.useMmap = inputs.useMmap;
+        this.vocabOnly = inputs.vocabOnly;
+        this._model = new node_llama_cpp_1.LlamaModel(inputs);
+        this._context = new node_llama_cpp_1.LlamaContext({ model: this._model });
+    }
+    _llmType() {
+        return "llama2_cpp";
+    }
+    /** @ignore */
+    async _call(prompt, options) {
+        const session = new node_llama_cpp_1.LlamaChatSession({ context: this._context });
+        try {
+            const compleation = await session.prompt(prompt, options);
+            return compleation;
+        }
+        catch (e) {
+            throw new Error("Error getting prompt compleation.");
+        }
+    }
+}
+exports.LlamaCpp = LlamaCpp;

package/dist/llms/llama_cpp.d.ts

@@ -0,0 +1,73 @@
+import { LlamaModel, LlamaContext } from "node-llama-cpp";
+import { LLM, BaseLLMCallOptions, BaseLLMParams } from "./base.js";
+/**
+ * Note that the modelPath is the only required parameter. For testing you
+ * can set this in the environment variable `LLAMA_PATH`.
+ */
+export interface LlamaCppInputs extends BaseLLMParams {
+    /** Prompt processing batch size. */
+    batchSize?: number;
+    /** Text context size. */
+    contextSize?: number;
+    /** Embedding mode only. */
+    embedding?: boolean;
+    /** Use fp16 for KV cache. */
+    f16Kv?: boolean;
+    /** Number of layers to store in VRAM. */
+    gpuLayers?: number;
+    /** The llama_eval() call computes all logits, not just the last one. */
+    logitsAll?: boolean;
+    /** If true, reduce VRAM usage at the cost of performance. */
+    lowVram?: boolean;
+    /** Path to the model on the filesystem. */
+    modelPath: string;
+    /** If null, a random seed will be used. */
+    seed?: null | number;
+    /** The randomness of the responses, e.g. 0.1 deterministic, 1.5 creative, 0.8 balanced, 0 disables. */
+    temperature?: number;
+    /** Consider the n most likely tokens, where n is 1 to vocabulary size, 0 disables (uses full vocabulary). Note: only applies when `temperature` > 0. */
+    topK?: number;
+    /** Selects the smallest token set whose probability exceeds P, where P is between 0 - 1, 1 disables. Note: only applies when `temperature` > 0. */
+    topP?: number;
+    /** Force system to keep model in RAM. */
+    useMlock?: boolean;
+    /** Use mmap if possible. */
+    useMmap?: boolean;
+    /** Only load the vocabulary, no weights. */
+    vocabOnly?: boolean;
+}
+export interface LlamaCppCallOptions extends BaseLLMCallOptions {
+    /** The maximum number of tokens the response should contain. */
+    maxTokens?: number;
+    /** A function called when matching the provided token array */
+    onToken?: (tokens: number[]) => void;
+}
+/**
+ *  To use this model you need to have the `node-llama-cpp` module installed.
+ *  This can be installed using `npm install -S node-llama-cpp` and the minimum
+ *  version supported in version 2.0.0.
+ *  This also requires that have a locally built version of Llama2 installed.
+ */
+export declare class LlamaCpp extends LLM<LlamaCppCallOptions> {
+    CallOptions: LlamaCppCallOptions;
+    static inputs: LlamaCppInputs;
+    batchSize?: number;
+    contextSize?: number;
+    embedding?: boolean;
+    f16Kv?: boolean;
+    gpuLayers?: number;
+    logitsAll?: boolean;
+    lowVram?: boolean;
+    seed?: null | number;
+    useMlock?: boolean;
+    useMmap?: boolean;
+    vocabOnly?: boolean;
+    modelPath: string;
+    _model: LlamaModel;
+    _context: LlamaContext;
+    static lc_name(): string;
+    constructor(inputs: LlamaCppInputs);
+    _llmType(): string;
+    /** @ignore */
+    _call(prompt: string, options?: this["ParsedCallOptions"]): Promise<string>;
+}

package/dist/llms/llama_cpp.js

@@ -0,0 +1,128 @@
+import { LlamaModel, LlamaContext, LlamaChatSession } from "node-llama-cpp";
+import { LLM } from "./base.js";
+/**
+ *  To use this model you need to have the `node-llama-cpp` module installed.
+ *  This can be installed using `npm install -S node-llama-cpp` and the minimum
+ *  version supported in version 2.0.0.
+ *  This also requires that have a locally built version of Llama2 installed.
+ */
+export class LlamaCpp extends LLM {
+    static lc_name() {
+        return "LlamaCpp";
+    }
+    constructor(inputs) {
+        super(inputs);
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contextSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embedding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "f16Kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gpuLayers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logitsAll", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lowVram", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "seed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useMlock", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useMmap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vocabOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.batchSize = inputs.batchSize;
+        this.contextSize = inputs.contextSize;
+        this.embedding = inputs.embedding;
+        this.f16Kv = inputs.f16Kv;
+        this.gpuLayers = inputs.gpuLayers;
+        this.logitsAll = inputs.logitsAll;
+        this.lowVram = inputs.lowVram;
+        this.modelPath = inputs.modelPath;
+        this.seed = inputs.seed;
+        this.useMlock = inputs.useMlock;
+        this.useMmap = inputs.useMmap;
+        this.vocabOnly = inputs.vocabOnly;
+        this._model = new LlamaModel(inputs);
+        this._context = new LlamaContext({ model: this._model });
+    }
+    _llmType() {
+        return "llama2_cpp";
+    }
+    /** @ignore */
+    async _call(prompt, options) {
+        const session = new LlamaChatSession({ context: this._context });
+        try {
+            const compleation = await session.prompt(prompt, options);
+            return compleation;
+        }
+        catch (e) {
+            throw new Error("Error getting prompt compleation.");
+        }
+    }
+}