langchain 0.0.137 → 0.0.139

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/experimental/chat_models/anthropic_functions.cjs

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicFunctions = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const index_js_1 = require("../../schema/index.cjs");
+const anthropic_js_1 = require("../../chat_models/anthropic.cjs");
+const prompt_js_1 = require("../../prompts/prompt.cjs");
+const convert_to_openai_js_1 = require("../../tools/convert_to_openai.cjs");
+const TOOL_SYSTEM_PROMPT = 
+/* #__PURE__ */
+prompt_js_1.PromptTemplate.fromTemplate(`In addition to responding, you can use tools.
+You have access to the following tools.
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> to specify the name,
+and the <tool_input></tool_input> tags to specify the parameters.
+Each parameter should be passed in as <$param_name>$value</$param_name>,
+Where $param_name is the name of the specific parameter, and $value
+is the value for that parameter.
+
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that accepts a single
+parameter 'query' that could run a google search, in order to search
+for the weather in SF you would respond:
+
+<tool>search</tool><tool_input><query>weather in SF</query></tool_input>
+<observation>64 degrees</observation>`);
+class AnthropicFunctions extends anthropic_js_1.ChatAnthropic {
+    static lc_name() {
+        return "AnthropicFunctions";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+    }
+    async _generate(messages, options, runManager) {
+        let promptMessages = messages;
+        let forced = false;
+        let functionCall;
+        if (options.tools) {
+            // eslint-disable-next-line no-param-reassign
+            options.functions = (options.functions ?? []).concat(options.tools.map(convert_to_openai_js_1.formatToOpenAIFunction));
+        }
+        if (options.functions !== undefined && options.functions.length > 0) {
+            const content = await TOOL_SYSTEM_PROMPT.format({
+                tools: JSON.stringify(options.functions, null, 2),
+            });
+            const systemMessage = new index_js_1.SystemMessage({ content });
+            promptMessages = [systemMessage].concat(promptMessages);
+            const stopSequences = options?.stop?.concat(anthropic_js_1.DEFAULT_STOP_SEQUENCES) ??
+                this.stopSequences ??
+                anthropic_js_1.DEFAULT_STOP_SEQUENCES;
+            // eslint-disable-next-line no-param-reassign
+            options.stop = stopSequences.concat(["</tool_input>"]);
+            if (options.function_call) {
+                if (typeof options.function_call === "string") {
+                    functionCall = JSON.parse(options.function_call).name;
+                }
+                else {
+                    functionCall = options.function_call.name;
+                }
+                forced = true;
+                const matchingFunction = options.functions.find((tool) => tool.name === functionCall);
+                if (!matchingFunction) {
+                    throw new Error(`No matching function found for passed "function_call"`);
+                }
+                promptMessages = promptMessages.concat([
+                    new index_js_1.AIMessage({
+                        content: `<tool>${functionCall}</tool>`,
+                    }),
+                ]);
+                // eslint-disable-next-line no-param-reassign
+                delete options.function_call;
+            }
+            // eslint-disable-next-line no-param-reassign
+            delete options.functions;
+        }
+        else if (options.function_call !== undefined) {
+            throw new Error(`If "function_call" is provided, "functions" must also be.`);
+        }
+        const chatResult = await super._generate(promptMessages, options, runManager);
+        const chatGenerationContent = chatResult.generations[0].message.content;
+        if (forced) {
+            const parser = new fast_xml_parser_1.XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new index_js_1.AIMessage({
+                content: "",
+                additional_kwargs: {
+                    function_call: {
+                        name: functionCall,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        else if (chatGenerationContent.includes("<tool>")) {
+            const parser = new fast_xml_parser_1.XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new index_js_1.AIMessage({
+                content: chatGenerationContent.split("<tool>")[0],
+                additional_kwargs: {
+                    function_call: {
+                        name: result.tool,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        return chatResult;
+    }
+    _llmType() {
+        return "anthropic_functions";
+    }
+    /** @ignore */
+    _combineLLMOutput() {
+        return [];
+    }
+}
+exports.AnthropicFunctions = AnthropicFunctions;

package/dist/experimental/chat_models/anthropic_functions.d.ts

@@ -0,0 +1,20 @@
+import type { ChatCompletionFunctions, CreateChatCompletionRequestFunctionCall } from "openai";
+import { BaseChatModelParams } from "../../chat_models/base.js";
+import { CallbackManagerForLLMRun } from "../../callbacks/manager.js";
+import { BaseMessage, ChatResult } from "../../schema/index.js";
+import { ChatAnthropic, type AnthropicInput } from "../../chat_models/anthropic.js";
+import { BaseLanguageModelCallOptions } from "../../base_language/index.js";
+import { StructuredTool } from "../../tools/base.js";
+export interface ChatAnthropicFunctionsCallOptions extends BaseLanguageModelCallOptions {
+    function_call?: CreateChatCompletionRequestFunctionCall;
+    functions?: ChatCompletionFunctions[];
+    tools?: StructuredTool[];
+}
+export declare class AnthropicFunctions extends ChatAnthropic<ChatAnthropicFunctionsCallOptions> {
+    static lc_name(): string;
+    constructor(fields?: Partial<AnthropicInput> & BaseChatModelParams);
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
+    _llmType(): string;
+    /** @ignore */
+    _combineLLMOutput(): never[];
+}

package/dist/experimental/chat_models/anthropic_functions.js

@@ -0,0 +1,125 @@
+import { XMLParser } from "fast-xml-parser";
+import { AIMessage, SystemMessage, } from "../../schema/index.js";
+import { ChatAnthropic, DEFAULT_STOP_SEQUENCES, } from "../../chat_models/anthropic.js";
+import { PromptTemplate } from "../../prompts/prompt.js";
+import { formatToOpenAIFunction } from "../../tools/convert_to_openai.js";
+const TOOL_SYSTEM_PROMPT = 
+/* #__PURE__ */
+PromptTemplate.fromTemplate(`In addition to responding, you can use tools.
+You have access to the following tools.
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> to specify the name,
+and the <tool_input></tool_input> tags to specify the parameters.
+Each parameter should be passed in as <$param_name>$value</$param_name>,
+Where $param_name is the name of the specific parameter, and $value
+is the value for that parameter.
+
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that accepts a single
+parameter 'query' that could run a google search, in order to search
+for the weather in SF you would respond:
+
+<tool>search</tool><tool_input><query>weather in SF</query></tool_input>
+<observation>64 degrees</observation>`);
+export class AnthropicFunctions extends ChatAnthropic {
+    static lc_name() {
+        return "AnthropicFunctions";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+    }
+    async _generate(messages, options, runManager) {
+        let promptMessages = messages;
+        let forced = false;
+        let functionCall;
+        if (options.tools) {
+            // eslint-disable-next-line no-param-reassign
+            options.functions = (options.functions ?? []).concat(options.tools.map(formatToOpenAIFunction));
+        }
+        if (options.functions !== undefined && options.functions.length > 0) {
+            const content = await TOOL_SYSTEM_PROMPT.format({
+                tools: JSON.stringify(options.functions, null, 2),
+            });
+            const systemMessage = new SystemMessage({ content });
+            promptMessages = [systemMessage].concat(promptMessages);
+            const stopSequences = options?.stop?.concat(DEFAULT_STOP_SEQUENCES) ??
+                this.stopSequences ??
+                DEFAULT_STOP_SEQUENCES;
+            // eslint-disable-next-line no-param-reassign
+            options.stop = stopSequences.concat(["</tool_input>"]);
+            if (options.function_call) {
+                if (typeof options.function_call === "string") {
+                    functionCall = JSON.parse(options.function_call).name;
+                }
+                else {
+                    functionCall = options.function_call.name;
+                }
+                forced = true;
+                const matchingFunction = options.functions.find((tool) => tool.name === functionCall);
+                if (!matchingFunction) {
+                    throw new Error(`No matching function found for passed "function_call"`);
+                }
+                promptMessages = promptMessages.concat([
+                    new AIMessage({
+                        content: `<tool>${functionCall}</tool>`,
+                    }),
+                ]);
+                // eslint-disable-next-line no-param-reassign
+                delete options.function_call;
+            }
+            // eslint-disable-next-line no-param-reassign
+            delete options.functions;
+        }
+        else if (options.function_call !== undefined) {
+            throw new Error(`If "function_call" is provided, "functions" must also be.`);
+        }
+        const chatResult = await super._generate(promptMessages, options, runManager);
+        const chatGenerationContent = chatResult.generations[0].message.content;
+        if (forced) {
+            const parser = new XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new AIMessage({
+                content: "",
+                additional_kwargs: {
+                    function_call: {
+                        name: functionCall,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        else if (chatGenerationContent.includes("<tool>")) {
+            const parser = new XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new AIMessage({
+                content: chatGenerationContent.split("<tool>")[0],
+                additional_kwargs: {
+                    function_call: {
+                        name: result.tool,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        return chatResult;
+    }
+    _llmType() {
+        return "anthropic_functions";
+    }
+    /** @ignore */
+    _combineLLMOutput() {
+        return [];
+    }
+}