langchain 0.0.137 → 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/ollama.cjs

@@ -32,6 +32,42 @@ class Ollama extends base_js_1.LLM {
             writable: true,
             value: "http://localhost:11434"
         });
+        Object.defineProperty(this, "embeddingOnly", {
+            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, "frequencyPenalty", {
+            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, "mainGpu", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "mirostat", {
             enumerable: true,
             configurable: true,
@@ -50,6 +86,12 @@ class Ollama extends base_js_1.LLM {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "numBatch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "numCtx", {
             enumerable: true,
             configurable: true,
@@ -62,12 +104,36 @@ class Ollama extends base_js_1.LLM {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "numGqa", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numKeep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "numThread", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "penalizeNewline", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "presencePenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "repeatLastN", {
             enumerable: true,
             configurable: true,
@@ -80,6 +146,18 @@ class Ollama extends base_js_1.LLM {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "ropeFrequencyBase", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ropeFrequencyScale", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "temperature", {
             enumerable: true,
             configurable: true,
@@ -110,23 +188,64 @@ class Ollama extends base_js_1.LLM {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "typicalP", {
+            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
+        });
         this.model = fields.model ?? this.model;
         this.baseUrl = fields.baseUrl?.endsWith("/")
             ? fields.baseUrl.slice(0, -1)
             : fields.baseUrl ?? this.baseUrl;
+        this.embeddingOnly = fields.embeddingOnly;
+        this.f16KV = fields.f16KV;
+        this.frequencyPenalty = fields.frequencyPenalty;
+        this.logitsAll = fields.logitsAll;
+        this.lowVram = fields.lowVram;
+        this.mainGpu = fields.mainGpu;
         this.mirostat = fields.mirostat;
         this.mirostatEta = fields.mirostatEta;
         this.mirostatTau = fields.mirostatTau;
+        this.numBatch = fields.numBatch;
         this.numCtx = fields.numCtx;
         this.numGpu = fields.numGpu;
+        this.numGqa = fields.numGqa;
+        this.numKeep = fields.numKeep;
         this.numThread = fields.numThread;
+        this.penalizeNewline = fields.penalizeNewline;
+        this.presencePenalty = fields.presencePenalty;
         this.repeatLastN = fields.repeatLastN;
         this.repeatPenalty = fields.repeatPenalty;
+        this.ropeFrequencyBase = fields.ropeFrequencyBase;
+        this.ropeFrequencyScale = fields.ropeFrequencyScale;
         this.temperature = fields.temperature;
         this.stop = fields.stop;
         this.tfsZ = fields.tfsZ;
         this.topK = fields.topK;
         this.topP = fields.topP;
+        this.typicalP = fields.typicalP;
+        this.useMLock = fields.useMLock;
+        this.useMMap = fields.useMMap;
+        this.vocabOnly = fields.vocabOnly;
     }
     _llmType() {
         return "ollama";
@@ -135,19 +254,36 @@ class Ollama extends base_js_1.LLM {
         return {
             model: this.model,
             options: {
+                embedding_only: this.embeddingOnly,
+                f16_kv: this.f16KV,
+                frequency_penalty: this.frequencyPenalty,
+                logits_all: this.logitsAll,
+                low_vram: this.lowVram,
+                main_gpu: this.mainGpu,
                 mirostat: this.mirostat,
                 mirostat_eta: this.mirostatEta,
                 mirostat_tau: this.mirostatTau,
+                num_batch: this.numBatch,
                 num_ctx: this.numCtx,
                 num_gpu: this.numGpu,
+                num_gqa: this.numGqa,
+                num_keep: this.numKeep,
                 num_thread: this.numThread,
+                penalize_newline: this.penalizeNewline,
+                presence_penalty: this.presencePenalty,
                 repeat_last_n: this.repeatLastN,
                 repeat_penalty: this.repeatPenalty,
+                rope_frequency_base: this.ropeFrequencyBase,
+                rope_frequency_scale: this.ropeFrequencyScale,
                 temperature: this.temperature,
                 stop: options?.stop ?? this.stop,
                 tfs_z: this.tfsZ,
                 top_k: this.topK,
                 top_p: this.topP,
+                typical_p: this.typicalP,
+                use_mlock: this.useMLock,
+                use_mmap: this.useMMap,
+                vocab_only: this.vocabOnly,
             },
         };
     }

package/dist/llms/ollama.d.ts

@@ -12,37 +12,71 @@ export declare class Ollama extends LLM implements OllamaInput {
     lc_serializable: boolean;
     model: string;
     baseUrl: string;
+    embeddingOnly?: boolean;
+    f16KV?: boolean;
+    frequencyPenalty?: number;
+    logitsAll?: boolean;
+    lowVram?: boolean;
+    mainGpu?: number;
     mirostat?: number;
     mirostatEta?: number;
     mirostatTau?: number;
+    numBatch?: number;
     numCtx?: number;
     numGpu?: number;
+    numGqa?: number;
+    numKeep?: number;
     numThread?: number;
+    penalizeNewline?: boolean;
+    presencePenalty?: number;
     repeatLastN?: number;
     repeatPenalty?: number;
+    ropeFrequencyBase?: number;
+    ropeFrequencyScale?: number;
     temperature?: number;
     stop?: string[];
     tfsZ?: number;
     topK?: number;
     topP?: number;
+    typicalP?: number;
+    useMLock?: boolean;
+    useMMap?: boolean;
+    vocabOnly?: boolean;
     constructor(fields: OllamaInput & BaseLLMParams);
     _llmType(): string;
     invocationParams(options?: this["ParsedCallOptions"]): {
         model: string;
         options: {
+            embedding_only: boolean | undefined;
+            f16_kv: boolean | undefined;
+            frequency_penalty: number | undefined;
+            logits_all: boolean | undefined;
+            low_vram: boolean | undefined;
+            main_gpu: number | undefined;
             mirostat: number | undefined;
             mirostat_eta: number | undefined;
             mirostat_tau: number | undefined;
+            num_batch: number | undefined;
             num_ctx: number | undefined;
             num_gpu: number | undefined;
+            num_gqa: number | undefined;
+            num_keep: number | undefined;
             num_thread: number | undefined;
+            penalize_newline: boolean | undefined;
+            presence_penalty: number | undefined;
             repeat_last_n: number | undefined;
             repeat_penalty: number | undefined;
+            rope_frequency_base: number | undefined;
+            rope_frequency_scale: number | undefined;
             temperature: number | undefined;
             stop: string[] | undefined;
             tfs_z: number | undefined;
             top_k: number | undefined;
             top_p: number | undefined;
+            typical_p: number | undefined;
+            use_mlock: boolean | undefined;
+            use_mmap: boolean | undefined;
+            vocab_only: boolean | undefined;
         };
     };
     _streamResponseChunks(input: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;