langchain 0.0.197-rc.1 → 0.0.198

package/dist/experimental/tools/pyinterpreter.d.ts

@@ -0,0 +1,18 @@
+import { loadPyodide, type PyodideInterface } from "pyodide";
+import { Tool, ToolParams } from "../../tools/base.js";
+export type PythonInterpreterToolParams = Parameters<typeof loadPyodide>[0] & ToolParams & {
+    instance: PyodideInterface;
+};
+export declare class PythonInterpreterTool extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    pyodideInstance: PyodideInterface;
+    stdout: string;
+    stderr: string;
+    constructor(options: PythonInterpreterToolParams);
+    addPackage(packageName: string): Promise<void>;
+    get availableDefaultPackages(): string;
+    static initialize(options: Omit<PythonInterpreterToolParams, "instance">): Promise<PythonInterpreterTool>;
+    _call(script: string): Promise<string>;
+}

package/dist/experimental/tools/pyinterpreter.js

@@ -0,0 +1,244 @@
+import { loadPyodide } from "pyodide";
+import { Tool } from "../../tools/base.js";
+export class PythonInterpreterTool extends Tool {
+    static lc_name() {
+        return "PythonInterpreterTool";
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "python_interpreter"
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: `Evaluates python code in a sandbox environment. The environment resets on every execution. You must send the whole script every time and print your outputs. Script should be pure python code that can be evaluated. Packages available:
+${this.availableDefaultPackages}`
+        });
+        Object.defineProperty(this, "pyodideInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stdout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "stderr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        this.pyodideInstance = options.instance;
+        this.pyodideInstance.setStderr({
+            batched: (text) => {
+                this.stderr += text;
+            },
+        });
+        this.pyodideInstance.setStdout({
+            batched: (text) => {
+                this.stdout += text;
+            },
+        });
+    }
+    async addPackage(packageName) {
+        await this.pyodideInstance.loadPackage(packageName);
+        this.description += `, ${packageName}`;
+    }
+    get availableDefaultPackages() {
+        return [
+            "asciitree",
+            "astropy",
+            "atomicwrites",
+            "attrs",
+            "autograd",
+            "awkward-cpp",
+            "bcrypt",
+            "beautifulsoup4",
+            "biopython",
+            "bitarray",
+            "bitstring",
+            "bleach",
+            "bokeh",
+            "boost-histogram",
+            "brotli",
+            "cachetools",
+            "Cartopy",
+            "cbor-diag",
+            "certifi",
+            "cffi",
+            "cffi_example",
+            "cftime",
+            "click",
+            "cligj",
+            "cloudpickle",
+            "cmyt",
+            "colorspacious",
+            "contourpy",
+            "coolprop",
+            "coverage",
+            "cramjam",
+            "cryptography",
+            "cssselect",
+            "cycler",
+            "cytoolz",
+            "decorator",
+            "demes",
+            "deprecation",
+            "distlib",
+            "docutils",
+            "exceptiongroup",
+            "fastparquet",
+            "fiona",
+            "fonttools",
+            "freesasa",
+            "fsspec",
+            "future",
+            "galpy",
+            "gensim",
+            "geopandas",
+            "gmpy2",
+            "gsw",
+            "h5py",
+            "html5lib",
+            "idna",
+            "igraph",
+            "imageio",
+            "iniconfig",
+            "jedi",
+            "Jinja2",
+            "joblib",
+            "jsonschema",
+            "kiwisolver",
+            "lazy-object-proxy",
+            "lazy_loader",
+            "lightgbm",
+            "logbook",
+            "lxml",
+            "MarkupSafe",
+            "matplotlib",
+            "matplotlib-pyodide",
+            "micropip",
+            "mne",
+            "more-itertools",
+            "mpmath",
+            "msgpack",
+            "msprime",
+            "multidict",
+            "munch",
+            "mypy",
+            "netcdf4",
+            "networkx",
+            "newick",
+            "nlopt",
+            "nltk",
+            "nose",
+            "numcodecs",
+            "numpy",
+            "opencv-python",
+            "optlang",
+            "orjson",
+            "packaging",
+            "pandas",
+            "parso",
+            "patsy",
+            "peewee",
+            "Pillow",
+            "pillow_heif",
+            "pkgconfig",
+            "pluggy",
+            "protobuf",
+            "py",
+            "pyb2d",
+            "pyclipper",
+            "pycparser",
+            "pycryptodome",
+            "pydantic",
+            "pyerfa",
+            "Pygments",
+            "pyheif",
+            "pyinstrument",
+            "pynacl",
+            "pyodide-http",
+            "pyodide-tblib",
+            "pyparsing",
+            "pyproj",
+            "pyrsistent",
+            "pyshp",
+            "pytest",
+            "pytest-benchmark",
+            "python-dateutil",
+            "python-magic",
+            "python-sat",
+            "python_solvespace",
+            "pytz",
+            "pywavelets",
+            "pyxel",
+            "pyyaml",
+            "rebound",
+            "reboundx",
+            "regex",
+            "retrying",
+            "RobotRaconteur",
+            "ruamel.yaml",
+            "rust-panic-test",
+            "scikit-image",
+            "scikit-learn",
+            "scipy",
+            "screed",
+            "setuptools",
+            "shapely",
+            "simplejson",
+            "six",
+            "smart_open",
+            "soupsieve",
+            "sourmash",
+            "sparseqr",
+            "sqlalchemy",
+            "statsmodels",
+            "svgwrite",
+            "swiglpk",
+            "sympy",
+            "termcolor",
+            "texttable",
+            "threadpoolctl",
+            "tomli",
+            "tomli-w",
+            "toolz",
+            "tqdm",
+            "traits",
+            "tskit",
+            "typing-extensions",
+            "uncertainties",
+            "unyt",
+            "webencodings",
+            "wordcloud",
+            "wrapt",
+            "xarray",
+            "xgboost",
+            "xlrd",
+            "xyzservices",
+            "yarl",
+            "yt",
+            "zarr",
+        ].join(", ");
+    }
+    static async initialize(options) {
+        const instance = await loadPyodide(options);
+        return new this({ ...options, instance });
+    }
+    async _call(script) {
+        this.stdout = "";
+        this.stderr = "";
+        await this.pyodideInstance.runPythonAsync(script);
+        return JSON.stringify({ stdout: this.stdout, stderr: this.stderr });
+    }
+}

package/dist/graphs/neo4j_graph.cjs

@@ -59,6 +59,16 @@ class Neo4jGraph {
             writable: true,
             value: ""
         });
+        Object.defineProperty(this, "structuredSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                nodeProps: {},
+                relProps: {},
+                relationships: [],
+            }
+        });
         try {
             this.driver = neo4j_driver_1.default.driver(url, neo4j_driver_1.default.auth.basic(username, password));
             this.database = database;
@@ -96,6 +106,9 @@ class Neo4jGraph {
     getSchema() {
         return this.schema;
     }
+    getStructuredSchema() {
+        return this.structuredSchema;
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async query(query, params = {}) {
         try {
@@ -138,21 +151,43 @@ class Neo4jGraph {
       YIELD label, other, elementType, type, property
       WHERE type = "RELATIONSHIP" AND elementType = "node"
       UNWIND other AS other_node
-      RETURN "(:" + label + ")-[:" + property + "]->(:" + toString(other_node) + ")" AS output
-    `;
-        const nodeProperties = await this.query(nodePropertiesQuery);
-        const relationshipsProperties = await this.query(relPropertiesQuery);
-        const relationships = await this.query(relQuery);
-        this.schema = `
-      Node properties are the following:
-      ${JSON.stringify(nodeProperties?.map((el) => el.output))}
-
-      Relationship properties are the following:
-      ${JSON.stringify(relationshipsProperties?.map((el) => el.output))}
-
-      The relationships are the following:
-      ${JSON.stringify(relationships?.map((el) => el.output))}
+      RETURN {start: label, type: property, end: toString(other_node)} AS output
     `;
+        // Assuming query method is defined and returns a Promise
+        const nodeProperties = (await this.query(nodePropertiesQuery))?.map((el) => el.output);
+        const relationshipsProperties = (await this.query(relPropertiesQuery))?.map((el) => el.output);
+        const relationships = (await this.query(relQuery))?.map((el) => el.output);
+        // Structured schema similar to Python's dictionary comprehension
+        this.structuredSchema = {
+            nodeProps: Object.fromEntries(nodeProperties?.map((el) => [el.labels, el.properties]) || []),
+            relProps: Object.fromEntries(relationshipsProperties?.map((el) => [el.type, el.properties]) || []),
+            relationships: relationships || [],
+        };
+        // Format node properties
+        const formattedNodeProps = nodeProperties?.map((el) => {
+            const propsStr = el.properties
+                .map((prop) => `${prop.property}: ${prop.type}`)
+                .join(", ");
+            return `${el.labels} {${propsStr}}`;
+        });
+        // Format relationship properties
+        const formattedRelProps = relationshipsProperties?.map((el) => {
+            const propsStr = el.properties
+                .map((prop) => `${prop.property}: ${prop.type}`)
+                .join(", ");
+            return `${el.type} {${propsStr}}`;
+        });
+        // Format relationships
+        const formattedRels = relationships?.map((el) => `(:${el.start})-[:${el.type}]->(:${el.end})`);
+        // Combine all formatted elements into a single string
+        this.schema = [
+            "Node properties are the following:",
+            formattedNodeProps?.join(", "),
+            "Relationship properties are the following:",
+            formattedRelProps?.join(", "),
+            "The relationships are the following:",
+            formattedRels?.join(", "),
+        ].join("\n");
     }
     async close() {
         await this.driver.close();

package/dist/graphs/neo4j_graph.d.ts

@@ -4,6 +4,34 @@ interface Neo4jGraphConfig {
     password: string;
     database?: string;
 }
+interface StructuredSchema {
+    nodeProps: {
+        [key: NodeType["labels"]]: NodeType["properties"];
+    };
+    relProps: {
+        [key: RelType["type"]]: RelType["properties"];
+    };
+    relationships: PathType[];
+}
+type NodeType = {
+    labels: string;
+    properties: {
+        property: string;
+        type: string;
+    }[];
+};
+type RelType = {
+    type: string;
+    properties: {
+        property: string;
+        type: string;
+    }[];
+};
+type PathType = {
+    start: string;
+    type: string;
+    end: string;
+};
 /**
  * @security *Security note*: Make sure that the database connection uses credentials
  * that are narrowly-scoped to only include necessary permissions.
@@ -22,9 +50,11 @@ export declare class Neo4jGraph {
     private driver;
     private database;
     private schema;
+    private structuredSchema;
     constructor({ url, username, password, database, }: Neo4jGraphConfig);
     static initialize(config: Neo4jGraphConfig): Promise<Neo4jGraph>;
     getSchema(): string;
+    getStructuredSchema(): StructuredSchema;
     query(query: string, params?: any): Promise<any[] | undefined>;
     verifyConnectivity(): Promise<void>;
     refreshSchema(): Promise<void>;

package/dist/graphs/neo4j_graph.js

@@ -33,6 +33,16 @@ export class Neo4jGraph {
             writable: true,
             value: ""
         });
+        Object.defineProperty(this, "structuredSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                nodeProps: {},
+                relProps: {},
+                relationships: [],
+            }
+        });
         try {
             this.driver = neo4j.driver(url, neo4j.auth.basic(username, password));
             this.database = database;
@@ -70,6 +80,9 @@ export class Neo4jGraph {
     getSchema() {
         return this.schema;
     }
+    getStructuredSchema() {
+        return this.structuredSchema;
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async query(query, params = {}) {
         try {
@@ -112,21 +125,43 @@ export class Neo4jGraph {
       YIELD label, other, elementType, type, property
       WHERE type = "RELATIONSHIP" AND elementType = "node"
       UNWIND other AS other_node
-      RETURN "(:" + label + ")-[:" + property + "]->(:" + toString(other_node) + ")" AS output
-    `;
-        const nodeProperties = await this.query(nodePropertiesQuery);
-        const relationshipsProperties = await this.query(relPropertiesQuery);
-        const relationships = await this.query(relQuery);
-        this.schema = `
-      Node properties are the following:
-      ${JSON.stringify(nodeProperties?.map((el) => el.output))}
-
-      Relationship properties are the following:
-      ${JSON.stringify(relationshipsProperties?.map((el) => el.output))}
-
-      The relationships are the following:
-      ${JSON.stringify(relationships?.map((el) => el.output))}
+      RETURN {start: label, type: property, end: toString(other_node)} AS output
     `;
+        // Assuming query method is defined and returns a Promise
+        const nodeProperties = (await this.query(nodePropertiesQuery))?.map((el) => el.output);
+        const relationshipsProperties = (await this.query(relPropertiesQuery))?.map((el) => el.output);
+        const relationships = (await this.query(relQuery))?.map((el) => el.output);
+        // Structured schema similar to Python's dictionary comprehension
+        this.structuredSchema = {
+            nodeProps: Object.fromEntries(nodeProperties?.map((el) => [el.labels, el.properties]) || []),
+            relProps: Object.fromEntries(relationshipsProperties?.map((el) => [el.type, el.properties]) || []),
+            relationships: relationships || [],
+        };
+        // Format node properties
+        const formattedNodeProps = nodeProperties?.map((el) => {
+            const propsStr = el.properties
+                .map((prop) => `${prop.property}: ${prop.type}`)
+                .join(", ");
+            return `${el.labels} {${propsStr}}`;
+        });
+        // Format relationship properties
+        const formattedRelProps = relationshipsProperties?.map((el) => {
+            const propsStr = el.properties
+                .map((prop) => `${prop.property}: ${prop.type}`)
+                .join(", ");
+            return `${el.type} {${propsStr}}`;
+        });
+        // Format relationships
+        const formattedRels = relationships?.map((el) => `(:${el.start})-[:${el.type}]->(:${el.end})`);
+        // Combine all formatted elements into a single string
+        this.schema = [
+            "Node properties are the following:",
+            formattedNodeProps?.join(", "),
+            "Relationship properties are the following:",
+            formattedRelProps?.join(", "),
+            "The relationships are the following:",
+            formattedRels?.join(", "),
+        ].join("\n");
     }
     async close() {
         await this.driver.close();

package/dist/llms/fireworks.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAIClient } from "@langchain/openai";
+import type { OpenAI as OpenAIClient } from "openai";
 import type { BaseLLMParams } from "./base.js";
 import type { OpenAICallOptions, OpenAIInput } from "./openai.js";
 import type { OpenAICoreRequestOptions } from "../types/openai-types.js";

package/dist/llms/hf.cjs

@@ -76,6 +76,12 @@ class HuggingFaceInference extends base_js_1.LLM {
             writable: true,
             value: undefined
         });
+        Object.defineProperty(this, "includeCredentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
         this.model = fields?.model ?? this.model;
         this.temperature = fields?.temperature ?? this.temperature;
         this.maxTokens = fields?.maxTokens ?? this.maxTokens;
@@ -85,6 +91,7 @@ class HuggingFaceInference extends base_js_1.LLM {
         this.apiKey =
             fields?.apiKey ?? (0, env_js_1.getEnvironmentVariable)("HUGGINGFACEHUB_API_KEY");
         this.endpointUrl = fields?.endpointUrl;
+        this.includeCredentials = fields?.includeCredentials;
         if (!this.apiKey) {
             throw new Error("Please set an API key for HuggingFace Hub in the environment variable HUGGINGFACEHUB_API_KEY or in the apiKey field of the HuggingFaceInference constructor.");
         }
@@ -96,8 +103,12 @@ class HuggingFaceInference extends base_js_1.LLM {
     async _call(prompt, options) {
         const { HfInference } = await HuggingFaceInference.imports();
         const hf = this.endpointUrl
-            ? new HfInference(this.apiKey).endpoint(this.endpointUrl)
-            : new HfInference(this.apiKey);
+            ? new HfInference(this.apiKey, {
+                includeCredentials: this.includeCredentials,
+            }).endpoint(this.endpointUrl)
+            : new HfInference(this.apiKey, {
+                includeCredentials: this.includeCredentials,
+            });
         const res = await this.caller.callWithOptions({ signal: options.signal }, hf.textGeneration.bind(hf), {
             model: this.model,
             parameters: {

package/dist/llms/hf.d.ts

@@ -22,6 +22,10 @@ export interface HFInput {
     frequencyPenalty?: number;
     /** API key to use. */
     apiKey?: string;
+    /**
+     * Credentials to use for the request. If this is a string, it will be passed straight on. If it's a boolean, true will be "include" and false will not send credentials at all.
+     */
+    includeCredentials?: string | boolean;
 }
 /**
  * Class implementing the Large Language Model (LLM) interface using the
@@ -52,6 +56,7 @@ export declare class HuggingFaceInference extends LLM implements HFInput {
     frequencyPenalty: number | undefined;
     apiKey: string | undefined;
     endpointUrl: string | undefined;
+    includeCredentials: string | boolean | undefined;
     constructor(fields?: Partial<HFInput> & BaseLLMParams);
     _llmType(): string;
     /** @ignore */

package/dist/llms/hf.js

@@ -73,6 +73,12 @@ export class HuggingFaceInference extends LLM {
             writable: true,
             value: undefined
         });
+        Object.defineProperty(this, "includeCredentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
         this.model = fields?.model ?? this.model;
         this.temperature = fields?.temperature ?? this.temperature;
         this.maxTokens = fields?.maxTokens ?? this.maxTokens;
@@ -82,6 +88,7 @@ export class HuggingFaceInference extends LLM {
         this.apiKey =
             fields?.apiKey ?? getEnvironmentVariable("HUGGINGFACEHUB_API_KEY");
         this.endpointUrl = fields?.endpointUrl;
+        this.includeCredentials = fields?.includeCredentials;
         if (!this.apiKey) {
             throw new Error("Please set an API key for HuggingFace Hub in the environment variable HUGGINGFACEHUB_API_KEY or in the apiKey field of the HuggingFaceInference constructor.");
         }
@@ -93,8 +100,12 @@ export class HuggingFaceInference extends LLM {
     async _call(prompt, options) {
         const { HfInference } = await HuggingFaceInference.imports();
         const hf = this.endpointUrl
-            ? new HfInference(this.apiKey).endpoint(this.endpointUrl)
-            : new HfInference(this.apiKey);
+            ? new HfInference(this.apiKey, {
+                includeCredentials: this.includeCredentials,
+            }).endpoint(this.endpointUrl)
+            : new HfInference(this.apiKey, {
+                includeCredentials: this.includeCredentials,
+            });
         const res = await this.caller.callWithOptions({ signal: options.signal }, hf.textGeneration.bind(hf), {
             model: this.model,
             parameters: {

package/dist/llms/llama_cpp.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlamaCpp = void 0;
 const llama_cpp_js_1 = require("../util/llama_cpp.cjs");
 const base_js_1 = require("./base.cjs");
+const index_js_1 = require("../schema/index.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
@@ -76,9 +77,7 @@ class LlamaCpp extends base_js_1.LLM {
         return "llama2_cpp";
     }
     /** @ignore */
-    async _call(prompt, 
-    // @ts-expect-error - TS6133: 'options' is declared but its value is never read.
-    options) {
+    async _call(prompt, _options) {
         try {
             const promptOptions = {
                 maxTokens: this?.maxTokens,
@@ -94,5 +93,20 @@ class LlamaCpp extends base_js_1.LLM {
             throw new Error("Error getting prompt completion.");
         }
     }
+    async *_streamResponseChunks(prompt, _options, runManager) {
+        const promptOptions = {
+            temperature: this?.temperature,
+            topK: this?.topK,
+            topP: this?.topP,
+        };
+        const stream = await this.caller.call(async () => this._context.evaluate(this._context.encode(prompt), promptOptions));
+        for await (const chunk of stream) {
+            yield new index_js_1.GenerationChunk({
+                text: this._context.decode([chunk]),
+                generationInfo: {},
+            });
+            await runManager?.handleLLMNewToken(this._context.decode([chunk]) ?? "");
+        }
+    }
 }
 exports.LlamaCpp = LlamaCpp;

package/dist/llms/llama_cpp.d.ts

@@ -1,6 +1,8 @@
 import { LlamaModel, LlamaContext, LlamaChatSession } from "node-llama-cpp";
 import { LlamaBaseCppInputs } from "../util/llama_cpp.js";
 import { LLM, BaseLLMCallOptions, BaseLLMParams } from "./base.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { GenerationChunk } from "../schema/index.js";
 /**
  * Note that the modelPath is the only required parameter. For testing you
  * can set this in the environment variable `LLAMA_PATH`.
@@ -34,5 +36,6 @@ export declare class LlamaCpp extends LLM<LlamaCppCallOptions> {
     constructor(inputs: LlamaCppInputs);
     _llmType(): string;
     /** @ignore */
-    _call(prompt: string, options?: this["ParsedCallOptions"]): Promise<string>;
+    _call(prompt: string, _options?: this["ParsedCallOptions"]): Promise<string>;
+    _streamResponseChunks(prompt: string, _options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
 }

package/dist/llms/llama_cpp.js

@@ -1,5 +1,6 @@
 import { createLlamaModel, createLlamaContext, createLlamaSession, } from "../util/llama_cpp.js";
 import { LLM } from "./base.js";
+import { GenerationChunk } from "../schema/index.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
@@ -73,9 +74,7 @@ export class LlamaCpp extends LLM {
         return "llama2_cpp";
     }
     /** @ignore */
-    async _call(prompt, 
-    // @ts-expect-error - TS6133: 'options' is declared but its value is never read.
-    options) {
+    async _call(prompt, _options) {
         try {
             const promptOptions = {
                 maxTokens: this?.maxTokens,
@@ -91,4 +90,19 @@ export class LlamaCpp extends LLM {
             throw new Error("Error getting prompt completion.");
         }
     }
+    async *_streamResponseChunks(prompt, _options, runManager) {
+        const promptOptions = {
+            temperature: this?.temperature,
+            topK: this?.topK,
+            topP: this?.topP,
+        };
+        const stream = await this.caller.call(async () => this._context.evaluate(this._context.encode(prompt), promptOptions));
+        for await (const chunk of stream) {
+            yield new GenerationChunk({
+                text: this._context.decode([chunk]),
+                generationInfo: {},
+            });
+            await runManager?.handleLLMNewToken(this._context.decode([chunk]) ?? "");
+        }
+    }
 }