langchain 0.0.163 → 0.0.165

package/dist/llms/sagemaker_endpoint.d.ts

@@ -1,5 +1,7 @@
 import { SageMakerRuntimeClient, SageMakerRuntimeClientConfig } from "@aws-sdk/client-sagemaker-runtime";
-import { LLM, BaseLLMParams } from "./base.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { GenerationChunk } from "../schema/index.js";
+import { BaseLLMCallOptions, BaseLLMParams, LLM } from "./base.js";
 /**
  * A handler class to transform input from LLM to a format that SageMaker
  * endpoint expects. Similarily, the class also handles transforming output from
@@ -28,22 +30,22 @@ import { LLM, BaseLLMParams } from "./base.js";
  * ```
  */
 export declare abstract class BaseSageMakerContentHandler<InputType, OutputType> {
-    /** The MIME type of the input data passed to endpoint */
     contentType: string;
-    /** The MIME type of the response data returned from endpoint */
     accepts: string;
     /**
-     * Transforms the input to a format that model can accept as the request Body.
-     * Should return bytes or seekable file like object in the format specified in
-     * the contentType request header.
+     * Transforms the prompt and model arguments into a specific format for sending to SageMaker.
+     * @param {InputType} prompt The prompt to be transformed.
+     * @param {Record<string, unknown>} modelKwargs Additional arguments.
+     * @returns {Promise<Uint8Array>} A promise that resolves to the formatted data for sending.
      */
     abstract transformInput(prompt: InputType, modelKwargs: Record<string, unknown>): Promise<Uint8Array>;
     /**
-     * Transforms the output from the model to string that the LLM class expects.
+     * Transforms SageMaker output into a desired format.
+     * @param {Uint8Array} output The raw output from SageMaker.
+     * @returns {Promise<OutputType>} A promise that resolves to the transformed data.
      */
     abstract transformOutput(output: Uint8Array): Promise<OutputType>;
 }
-/** Content handler for LLM class. */
 export type SageMakerLLMContentHandler = BaseSageMakerContentHandler<string, string>;
 /**
  * The SageMakerEndpointInput interface defines the input parameters for
@@ -61,11 +63,6 @@ export interface SageMakerEndpointInput extends BaseLLMParams {
      * Options passed to the SageMaker client.
      */
     clientOptions: SageMakerRuntimeClientConfig;
-    /**
-     * The content handler class that provides an input and output transform
-     * functions to handle formats between LLM and the endpoint.
-     */
-    contentHandler: SageMakerLLMContentHandler;
     /**
      * Key word arguments to pass to the model.
      */
@@ -74,29 +71,51 @@ export interface SageMakerEndpointInput extends BaseLLMParams {
      * Optional attributes passed to the InvokeEndpointCommand
      */
     endpointKwargs?: Record<string, unknown>;
+    /**
+     * The content handler class that provides an input and output transform
+     * functions to handle formats between LLM and the endpoint.
+     */
+    contentHandler: SageMakerLLMContentHandler;
+    streaming?: boolean;
 }
 /**
  * The SageMakerEndpoint class is used to interact with SageMaker
- * Inference Endpoint models. It extends the LLM class and overrides the
- * _call method to transform the input and output between the LLM and the
- * SageMaker endpoint using the provided content handler. The class uses
- * AWS client for authentication, which automatically loads credentials.
+ * Inference Endpoint models. It uses the AWS client for authentication,
+ * which automatically loads credentials.
  * If a specific credential profile is to be used, the name of the profile
  * from the ~/.aws/credentials file must be passed. The credentials or
  * roles used should have the required policies to access the SageMaker
  * endpoint.
  */
-export declare class SageMakerEndpoint extends LLM {
+export declare class SageMakerEndpoint extends LLM<BaseLLMCallOptions> {
+    static lc_name(): string;
     get lc_secrets(): {
         [key: string]: string;
     } | undefined;
     endpointName: string;
-    contentHandler: SageMakerLLMContentHandler;
     modelKwargs?: Record<string, unknown>;
     endpointKwargs?: Record<string, unknown>;
     client: SageMakerRuntimeClient;
+    contentHandler: SageMakerLLMContentHandler;
+    streaming: boolean;
     constructor(fields: SageMakerEndpointInput);
     _llmType(): string;
+    /**
+     * Calls the SageMaker endpoint and retrieves the result.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @param {CallbackManagerForLLMRun} _runManager Optional run manager.
+     * @returns {Promise<string>} A promise that resolves to the generated string.
+     */
     /** @ignore */
-    _call(prompt: string, options: this["ParsedCallOptions"]): Promise<string>;
+    _call(prompt: string, options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<string>;
+    private streamingCall;
+    private noStreamingCall;
+    /**
+     * Streams response chunks from the SageMaker endpoint.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @returns {AsyncGenerator<GenerationChunk>} An asynchronous generator yielding generation chunks.
+     */
+    _streamResponseChunks(prompt: string, options: this["ParsedCallOptions"]): AsyncGenerator<GenerationChunk>;
 }

package/dist/llms/sagemaker_endpoint.js

@@ -1,4 +1,5 @@
-import { SageMakerRuntimeClient, InvokeEndpointCommand, } from "@aws-sdk/client-sagemaker-runtime";
+import { InvokeEndpointCommand, InvokeEndpointWithResponseStreamCommand, SageMakerRuntimeClient, } from "@aws-sdk/client-sagemaker-runtime";
+import { GenerationChunk } from "../schema/index.js";
 import { LLM } from "./base.js";
 /**
  * A handler class to transform input from LLM to a format that SageMaker
@@ -29,14 +30,12 @@ import { LLM } from "./base.js";
  */
 export class BaseSageMakerContentHandler {
     constructor() {
-        /** The MIME type of the input data passed to endpoint */
         Object.defineProperty(this, "contentType", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "text/plain"
         });
-        /** The MIME type of the response data returned from endpoint */
         Object.defineProperty(this, "accepts", {
             enumerable: true,
             configurable: true,
@@ -47,16 +46,17 @@ export class BaseSageMakerContentHandler {
 }
 /**
  * The SageMakerEndpoint class is used to interact with SageMaker
- * Inference Endpoint models. It extends the LLM class and overrides the
- * _call method to transform the input and output between the LLM and the
- * SageMaker endpoint using the provided content handler. The class uses
- * AWS client for authentication, which automatically loads credentials.
+ * Inference Endpoint models. It uses the AWS client for authentication,
+ * which automatically loads credentials.
  * If a specific credential profile is to be used, the name of the profile
  * from the ~/.aws/credentials file must be passed. The credentials or
  * roles used should have the required policies to access the SageMaker
  * endpoint.
  */
 export class SageMakerEndpoint extends LLM {
+    static lc_name() {
+        return "SageMakerEndpoint";
+    }
     get lc_secrets() {
         return {
             "clientOptions.credentials.accessKeyId": "AWS_ACCESS_KEY_ID",
@@ -65,39 +65,44 @@ export class SageMakerEndpoint extends LLM {
         };
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(fields);
         Object.defineProperty(this, "endpointName", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "contentHandler", {
+        Object.defineProperty(this, "modelKwargs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modelKwargs", {
+        Object.defineProperty(this, "endpointKwargs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "endpointKwargs", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "client", {
+        Object.defineProperty(this, "contentHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        const regionName = fields.clientOptions.region;
-        if (!regionName) {
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.clientOptions.region) {
             throw new Error(`Please pass a "clientOptions" object with a "region" field to the constructor`);
         }
         const endpointName = fields?.endpointName;
@@ -112,13 +117,33 @@ export class SageMakerEndpoint extends LLM {
         this.contentHandler = fields.contentHandler;
         this.endpointKwargs = fields.endpointKwargs;
         this.modelKwargs = fields.modelKwargs;
+        this.streaming = fields.streaming ?? false;
         this.client = new SageMakerRuntimeClient(fields.clientOptions);
     }
     _llmType() {
         return "sagemaker_endpoint";
     }
+    /**
+     * Calls the SageMaker endpoint and retrieves the result.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @param {CallbackManagerForLLMRun} _runManager Optional run manager.
+     * @returns {Promise<string>} A promise that resolves to the generated string.
+     */
     /** @ignore */
-    async _call(prompt, options) {
+    async _call(prompt, options, _runManager) {
+        return this.streaming
+            ? await this.streamingCall(prompt, options)
+            : await this.noStreamingCall(prompt, options);
+    }
+    async streamingCall(prompt, options) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(prompt, options)) {
+            chunks.push(chunk.text);
+        }
+        return chunks.join("");
+    }
+    async noStreamingCall(prompt, options) {
         const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
         const { contentType, accepts } = this.contentHandler;
         const response = await this.caller.call(() => this.client.send(new InvokeEndpointCommand({
@@ -133,4 +158,41 @@ export class SageMakerEndpoint extends LLM {
         }
         return this.contentHandler.transformOutput(response.Body);
     }
+    /**
+     * Streams response chunks from the SageMaker endpoint.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @returns {AsyncGenerator<GenerationChunk>} An asynchronous generator yielding generation chunks.
+     */
+    async *_streamResponseChunks(prompt, options) {
+        const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
+        const { contentType, accepts } = this.contentHandler;
+        const stream = await this.caller.call(() => this.client.send(new InvokeEndpointWithResponseStreamCommand({
+            EndpointName: this.endpointName,
+            Body: body,
+            ContentType: contentType,
+            Accept: accepts,
+            ...this.endpointKwargs,
+        }), { abortSignal: options.signal }));
+        if (!stream.Body) {
+            throw new Error("Inference result missing Body");
+        }
+        for await (const chunk of stream.Body) {
+            if (chunk.PayloadPart && chunk.PayloadPart.Bytes) {
+                yield new GenerationChunk({
+                    text: await this.contentHandler.transformOutput(chunk.PayloadPart.Bytes),
+                    generationInfo: {
+                        ...chunk,
+                        response: undefined,
+                    },
+                });
+            }
+            else if (chunk.InternalStreamFailure) {
+                throw new Error(chunk.InternalStreamFailure.message);
+            }
+            else if (chunk.ModelStreamError) {
+                throw new Error(chunk.ModelStreamError.message);
+            }
+        }
+    }
 }

package/dist/load/import_constants.cjs

@@ -37,8 +37,10 @@ exports.optionalImportEntrypoints = [
     "langchain/llms/bedrock",
     "langchain/llms/llama_cpp",
     "langchain/llms/writer",
+    "langchain/llms/portkey",
     "langchain/prompts/load",
     "langchain/vectorstores/analyticdb",
+    "langchain/vectorstores/cassandra",
     "langchain/vectorstores/elasticsearch",
     "langchain/vectorstores/cloudflare_vectorize",
     "langchain/vectorstores/chroma",
@@ -101,6 +103,7 @@ exports.optionalImportEntrypoints = [
     "langchain/document_loaders/fs/openai_whisper_audio",
     "langchain/document_transformers/html_to_text",
     "langchain/document_transformers/mozilla_readability",
+    "langchain/chat_models/portkey",
     "langchain/chat_models/bedrock",
     "langchain/chat_models/googlevertexai",
     "langchain/chat_models/googlevertexai/web",

package/dist/load/import_constants.js

@@ -34,8 +34,10 @@ export const optionalImportEntrypoints = [
     "langchain/llms/bedrock",
     "langchain/llms/llama_cpp",
     "langchain/llms/writer",
+    "langchain/llms/portkey",
     "langchain/prompts/load",
     "langchain/vectorstores/analyticdb",
+    "langchain/vectorstores/cassandra",
     "langchain/vectorstores/elasticsearch",
     "langchain/vectorstores/cloudflare_vectorize",
     "langchain/vectorstores/chroma",
@@ -98,6 +100,7 @@ export const optionalImportEntrypoints = [
     "langchain/document_loaders/fs/openai_whisper_audio",
     "langchain/document_transformers/html_to_text",
     "langchain/document_transformers/mozilla_readability",
+    "langchain/chat_models/portkey",
     "langchain/chat_models/bedrock",
     "langchain/chat_models/googlevertexai",
     "langchain/chat_models/googlevertexai/web",

package/dist/output_parsers/list.cjs

@@ -119,7 +119,7 @@ class CustomListOutputParser extends ListOutputParser {
      * @returns A string containing instructions on the expected format of the response.
      */
     getFormatInstructions() {
-        return `Your response should be a list of ${this.length} items separated by "${this.separator}" (eg: \`foo${this.separator} bar${this.separator} baz\`)`;
+        return `Your response should be a list of ${this.length === undefined ? "" : `${this.length} `}items separated by "${this.separator}" (eg: \`foo${this.separator} bar${this.separator} baz\`)`;
     }
 }
 exports.CustomListOutputParser = CustomListOutputParser;

package/dist/output_parsers/list.js

@@ -114,6 +114,6 @@ export class CustomListOutputParser extends ListOutputParser {
      * @returns A string containing instructions on the expected format of the response.
      */
     getFormatInstructions() {
-        return `Your response should be a list of ${this.length} items separated by "${this.separator}" (eg: \`foo${this.separator} bar${this.separator} baz\`)`;
+        return `Your response should be a list of ${this.length === undefined ? "" : `${this.length} `}items separated by "${this.separator}" (eg: \`foo${this.separator} bar${this.separator} baz\`)`;
     }
 }

package/dist/util/stream.cjs

@@ -38,7 +38,7 @@ class IterableReadableStream extends ReadableStream {
         const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
         this.reader.releaseLock(); // release lock first
         await cancelPromise; // now await it
-        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore chunk value anyway
+        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
     }
     [Symbol.asyncIterator]() {
         return this;
@@ -68,12 +68,12 @@ class IterableReadableStream extends ReadableStream {
         return new IterableReadableStream({
             async pull(controller) {
                 const { value, done } = await generator.next();
+                // When no more data needs to be consumed, close the stream
                 if (done) {
                     controller.close();
                 }
-                else if (value) {
-                    controller.enqueue(value);
-                }
+                // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled
+                controller.enqueue(value);
             },
         });
     }

package/dist/util/stream.js

@@ -35,7 +35,7 @@ export class IterableReadableStream extends ReadableStream {
         const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
         this.reader.releaseLock(); // release lock first
         await cancelPromise; // now await it
-        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore chunk value anyway
+        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
     }
     [Symbol.asyncIterator]() {
         return this;
@@ -65,12 +65,12 @@ export class IterableReadableStream extends ReadableStream {
         return new IterableReadableStream({
             async pull(controller) {
                 const { value, done } = await generator.next();
+                // When no more data needs to be consumed, close the stream
                 if (done) {
                     controller.close();
                 }
-                else if (value) {
-                    controller.enqueue(value);
-                }
+                // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled
+                controller.enqueue(value);
             },
         });
     }

package/dist/vectorstores/cassandra.cjs

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CassandraStore = void 0;
+/* eslint-disable prefer-template */
+const cassandra_driver_1 = require("cassandra-driver");
+const base_js_1 = require("./base.cjs");
+const document_js_1 = require("../document.cjs");
+/**
+ * Class for interacting with the Cassandra database. It extends the
+ * VectorStore class and provides methods for adding vectors and
+ * documents, searching for similar vectors, and creating instances from
+ * texts or documents.
+ */
+class CassandraStore extends base_js_1.VectorStore {
+    _vectorstoreType() {
+        return "cassandra";
+    }
+    constructor(embeddings, args) {
+        super(embeddings, args);
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "dimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyspace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "primaryKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadataColumns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "table", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.client = new cassandra_driver_1.Client(args);
+        this.dimensions = args.dimensions;
+        this.keyspace = args.keyspace;
+        this.table = args.table;
+        this.primaryKey = args.primaryKey;
+        this.metadataColumns = args.metadataColumns;
+    }
+    /**
+     * Method to save vectors to the Cassandra database.
+     * @param vectors Vectors to save.
+     * @param documents The documents associated with the vectors.
+     * @returns Promise that resolves when the vectors have been added.
+     */
+    async addVectors(vectors, documents) {
+        if (vectors.length === 0) {
+            return;
+        }
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        const queries = this.buildInsertQuery(vectors, documents);
+        await this.client.batch(queries);
+    }
+    /**
+     * Method to add documents to the Cassandra database.
+     * @param documents The documents to add.
+     * @returns Promise that resolves when the documents have been added.
+     */
+    async addDocuments(documents) {
+        return this.addVectors(await this.embeddings.embedDocuments(documents.map((d) => d.pageContent)), documents);
+    }
+    /**
+     * Method to search for vectors that are similar to a given query vector.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @returns Promise that resolves with an array of tuples, each containing a Document and a score.
+     */
+    async similaritySearchVectorWithScore(query, k) {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        const queryStr = this.buildSearchQuery(query, k);
+        const queryResultSet = await this.client.execute(queryStr);
+        return queryResultSet?.rows.map((row, index) => {
+            const textContent = row.text;
+            const sanitizedRow = Object.assign(row, {});
+            delete sanitizedRow.vector;
+            delete sanitizedRow.text;
+            return [
+                new document_js_1.Document({ pageContent: textContent, metadata: sanitizedRow }),
+                index,
+            ];
+        });
+    }
+    /**
+     * Static method to create an instance of CassandraStore from texts.
+     * @param texts The texts to use.
+     * @param metadatas The metadata associated with the texts.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the CassandraStore.
+     * @returns Promise that resolves with a new instance of CassandraStore.
+     */
+    static async fromTexts(texts, metadatas, embeddings, args) {
+        const docs = [];
+        for (let index = 0; index < texts.length; index += 1) {
+            const metadata = Array.isArray(metadatas) ? metadatas[index] : metadatas;
+            const doc = new document_js_1.Document({
+                pageContent: texts[index],
+                metadata,
+            });
+            docs.push(doc);
+        }
+        return CassandraStore.fromDocuments(docs, embeddings, args);
+    }
+    /**
+     * Static method to create an instance of CassandraStore from documents.
+     * @param docs The documents to use.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the CassandraStore.
+     * @returns Promise that resolves with a new instance of CassandraStore.
+     */
+    static async fromDocuments(docs, embeddings, args) {
+        const instance = new this(embeddings, args);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+    /**
+     * Static method to create an instance of CassandraStore from an existing
+     * index.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the CassandraStore.
+     * @returns Promise that resolves with a new instance of CassandraStore.
+     */
+    static async fromExistingIndex(embeddings, args) {
+        const instance = new this(embeddings, args);
+        await instance.initialize();
+        return instance;
+    }
+    /**
+     * Method to initialize the Cassandra database.
+     * @returns Promise that resolves when the database has been initialized.
+     */
+    async initialize() {
+        await this.client.execute(`CREATE TABLE IF NOT EXISTS ${this.keyspace}.${this.table} (
+      ${this.primaryKey.name} ${this.primaryKey.type} PRIMARY KEY,
+      text TEXT,
+      ${this.metadataColumns.length > 0
+            ? this.metadataColumns.map((col) => `${col.name} ${col.type},`)
+            : ""}
+      vector VECTOR<FLOAT, ${this.dimensions}>
+    );`);
+        await this.client.execute(`CREATE CUSTOM INDEX IF NOT EXISTS ann_index 
+  ON ${this.keyspace}.${this.table}(vector) USING 'StorageAttachedIndex';`);
+        this.isInitialized = true;
+    }
+    /**
+     * Method to build an CQL query for inserting vectors and documents into
+     * the Cassandra database.
+     * @param vectors The vectors to insert.
+     * @param documents The documents to insert.
+     * @returns The CQL query string.
+     */
+    buildInsertQuery(vectors, documents) {
+        const queries = [];
+        for (let index = 0; index < vectors.length; index += 1) {
+            const vector = vectors[index];
+            const document = documents[index];
+            const metadataColNames = Object.keys(document.metadata);
+            const metadataVals = Object.values(document.metadata);
+            const query = `INSERT INTO ${this.keyspace}.${this.table} (vector, text${metadataColNames.length > 0 ? ", " + metadataColNames.join(", ") : ""}) VALUES ([${vector}], '${document.pageContent}'${metadataVals.length > 0
+                ? ", " +
+                    metadataVals
+                        .map((val) => (typeof val === "number" ? val : `'${val}'`))
+                        .join(", ")
+                : ""});`;
+            queries.push(query);
+        }
+        return queries;
+    }
+    /**
+     * Method to build an CQL query for searching for similar vectors in the
+     * Cassandra database.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @returns The CQL query string.
+     */
+    buildSearchQuery(query, k) {
+        return `SELECT * FROM ${this.keyspace}.${this.table} ORDER BY vector ANN OF [${query}] LIMIT ${k || 1};`;
+    }
+}
+exports.CassandraStore = CassandraStore;