一个节点,用于运行上一个 AIMessage 中请求的工具。它可以在 StateGraph 中与 "messages" 键一起使用,也可以在 MessageGraph 中使用。如果请求了多个工具调用,它们将并行运行。输出将是一个 ToolMessages 列表,每个工具调用对应一个。

示例

import { ToolNode } from "@langchain/langgraph/prebuilt";
import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { AIMessage } from "@langchain/core/messages";

const getWeather = tool((input) => {
if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
return "It's 60 degrees and foggy.";
} else {
return "It's 90 degrees and sunny.";
}
}, {
name: "get_weather",
description: "Call to get the current weather.",
schema: z.object({
location: z.string().describe("Location to get the weather for."),
}),
});

const tools = [getWeather];
const toolNode = new ToolNode(tools);

const messageWithSingleToolCall = new AIMessage({
content: "",
tool_calls: [
{
name: "get_weather",
args: { location: "sf" },
id: "tool_call_id",
type: "tool_call",
}
]
})

await toolNode.invoke({ messages: [messageWithSingleToolCall] });
// Returns tool invocation responses as:
// { messages: ToolMessage[] }

示例

import {
StateGraph,
MessagesAnnotation,
} from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { ChatAnthropic } from "@langchain/anthropic";

const getWeather = tool((input) => {
if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
return "It's 60 degrees and foggy.";
} else {
return "It's 90 degrees and sunny.";
}
}, {
name: "get_weather",
description: "Call to get the current weather.",
schema: z.object({
location: z.string().describe("Location to get the weather for."),
}),
});

const tools = [getWeather];
const modelWithTools = new ChatAnthropic({
model: "claude-3-haiku-20240307",
temperature: 0
}).bindTools(tools);

const toolNodeForGraph = new ToolNode(tools)

const shouldContinue = (state: typeof MessagesAnnotation.State) => {
const { messages } = state;
const lastMessage = messages[messages.length - 1];
if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
return "tools";
}
return "__end__";
}

const callModel = async (state: typeof MessagesAnnotation.State) => {
const { messages } = state;
const response = await modelWithTools.invoke(messages);
return { messages: response };
}

const graph = new StateGraph(MessagesAnnotation)
.addNode("agent", callModel)
.addNode("tools", toolNodeForGraph)
.addEdge("__start__", "agent")
.addConditionalEdges("agent", shouldContinue)
.addEdge("tools", "agent")
.compile();

const inputs = {
messages: [{ role: "user", content: "what is the weather in SF?" }],
};

const stream = await graph.stream(inputs, {
streamMode: "values",
});

for await (const { messages } of stream) {
console.log(messages);
}
// Returns the messages in the state at each step of execution

类型参数

  • T = any

继承

  • RunnableCallable<T, T>
    • ToolNode

构造函数

  • 类型参数

    • T = any

    参数

    • tools: (RunnableToolLike<ZodType<any, ZodTypeDef, any>, unknown> | StructuredToolInterface<ZodObjectAny> | DynamicTool)[]
    • 可选 options: ToolNodeOptions

    返回 ToolNode<T>

属性

config?: RunnableConfig<Record<string, any>>
func: ((...args) => any)

类型声明

    • (...args): any
    • 参数

      • 剩余参数 ...args: any[]

      返回 any

handleToolErrors: boolean
lc_kwargs: SerializedFields
lc_namespace: string[]
lc_runnable: boolean
lc_serializable: boolean
name?: string
recurse: boolean
tags?: string[]
tools: (RunnableToolLike<ZodType<any, ZodTypeDef, any>, unknown> | StructuredToolInterface<ZodObjectAny> | DynamicTool)[]
trace: boolean

访问器

  • get lc_aliases(): undefined | {
        [key: string]: string;
    }
  • 构造函数参数的别名映射。键是属性名称,例如 "foo"。值是在序列化中将替换键的别名。这用于例如使参数名称与 Python 匹配。

    返回 undefined | {
        [key: string]: string;
    }

  • get lc_attributes(): undefined | SerializedFields
  • 要与构造函数参数合并的附加属性映射。键是属性名称,例如 "foo"。值是属性值,将被序列化。这些属性需要被构造函数接受为参数。

    返回 undefined | SerializedFields

  • get lc_id(): string[]
  • 模块的最终序列化标识符。

    返回 string[]

  • get lc_secrets(): undefined | {
        [key: string]: string;
    }
  • 秘密映射,这些秘密将从序列化中省略。键是构造函数参数中秘密的路径,例如 "foo.bar.baz"。值是秘密 ID,将在反序列化时使用。

    返回 undefined | {
        [key: string]: string;
    }

  • get lc_serializable_keys(): undefined | string[]
  • 应序列化的键的手动列表。如果未被覆盖,所有传入构造函数的字段都将被序列化。

    返回 undefined | string[]

方法

  • 处理可运行对象的批处理和配置的内部方法。它接受一个函数、输入值和可选配置,并返回一个解析为输出值的 Promise。

    类型参数

    • T

    参数

    • func: ((inputs, options?, runManagers?, batchOptions?) => Promise<(Error | T)[]>)

      为每个输入值执行的函数。

        • (inputs, options?, runManagers?, batchOptions?): Promise<(Error | T)[]>
        • 参数

          • inputs: T[]
          • 可选 options: Partial<RunnableConfig<Record<string, any>>>[]
          • 可选 runManagers: (undefined | CallbackManagerForChainRun)[]
          • 可选 batchOptions: RunnableBatchOptions

          返回 Promise<(Error | T)[]>

    • inputs: T[]
    • 可选 options: Partial<RunnableConfig<Record<string, any>> & {
          runType?: string;
      }> | Partial<RunnableConfig<Record<string, any>> & {
          runType?: string;
      }>[]
    • 可选 batchOptions: RunnableBatchOptions

    返回 Promise<(Error | T)[]>

    一个解析为输出值的 Promise。

  • 类型参数

    • T

    参数

    • func: ((input) => Promise<T>) | ((input, config?, runManager?) => Promise<T>)
    • input: T
    • 可选 options: Partial<RunnableConfig<Record<string, any>>> & {
          runType?: string;
      }

    返回 Promise<T>

  • 类型参数

    • O extends RunnableConfig<Record<string, any>> & {
          runType?: string;
      }

    参数

    • options: Partial<O> | Partial<O>[]
    • 可选 length: number

    返回 Partial<O>[]

  • 参数

    • 可选 options: Partial<RunnableConfig<Record<string, any>>>

    返回 [RunnableConfig<Record<string, any>>, Omit<Partial<RunnableConfig<Record<string, any>>>, keyof RunnableConfig<Record<string, any>>>]

  • 默认的流式实现。如果子类支持流式输出,应覆盖此方法。

    参数

    • input: T
    • 可选 options: Partial<RunnableConfig<Record<string, any>>>

    返回 AsyncGenerator<T, any, any>

  • 参数

    • input: T
    • logStreamCallbackHandler: LogStreamCallbackHandler
    • config: Partial<RunnableConfig<Record<string, any>>>

    返回 AsyncGenerator<RunLogPatch, any, any>

  • 参数

    • input: T
    • 可选 config: Partial<RunnableConfig<Record<string, any>>>
    • 可选 runManager: CallbackManagerForChainRun

    返回 Promise<T>

  • 辅助方法,用于将输入值的迭代器转换为输出值的迭代器,并带有回调。使用此方法在 Runnable 子类中实现 stream()transform()

    类型参数

    • I
    • O

    参数

    • inputGenerator: AsyncGenerator<I, any, any>
    • transformer: ((generator, runManager?, options?) => AsyncGenerator<O, any, any>)
        • (generator, runManager?, options?): AsyncGenerator<O, any, any>
        • 参数

          • generator: AsyncGenerator<I, any, any>
          • 可选 runManager: CallbackManagerForChainRun
          • 可选 options: Partial<RunnableConfig<Record<string, any>>>

          返回 AsyncGenerator<O, any, any>

    • 可选 options: Partial<RunnableConfig<Record<string, any>>> & {
          runType?: string;
      }

    返回 AsyncGenerator<O, any, any>

  • 将可运行对象转换为工具。返回 RunnableToolLike 的新实例,其中包含可运行对象、名称、描述和模式。

    类型参数

    • T = T

    参数

    • fields: {
          description?: string;
          name?: string;
          schema: ZodType<T, ZodTypeDef, T>;
      }
      • 可选 description?: string

        工具的描述。如果未提供,则回退到 Zod 模式上的描述,如果两者都未提供,则为 undefined。

      • 可选 name?: string

        工具的名称。如果未提供,将默认为可运行对象的名称。

      • schema: ZodType<T, ZodTypeDef, T>

        工具输入的 Zod 模式。从可运行对象的输入类型推断 Zod 类型。

    返回 RunnableToolLike<ZodType<ToolCall | T, ZodTypeDef, ToolCall | T>, T>

    RunnableToolLike 的一个实例,这是一个可用作工具的可运行对象。

  • 将新字段分配给此可运行对象的字典输出。返回一个新的可运行对象。

    参数

    • mapping: RunnableMapLike<Record<string, unknown>, Record<string, unknown>>

    返回 Runnable<any, any, RunnableConfig<Record<string, any>>>

  • 默认的批处理实现,调用 invoke N 次。如果子类可以更有效地进行批处理,则应覆盖此方法。

    参数

    • inputs: T[]

      每个批处理调用的输入数组。

    • 可选 options: Partial<RunnableConfig<Record<string, any>>> | Partial<RunnableConfig<Record<string, any>>>[]

      可以是应用于每个批处理调用的单个调用选项对象,也可以是每个调用的数组。

    • 可选 batchOptions: RunnableBatchOptions & {
          returnExceptions?: false;
      }

    返回 Promise<T[]>

    RunOutputs 数组,如果设置了 batchOptions.returnExceptions,则为 RunOutputs 和错误的混合数组。

  • 参数

    • inputs: T[]
    • 可选 options: Partial<RunnableConfig<Record<string, any>>> | Partial<RunnableConfig<Record<string, any>>>[]
    • 可选 batchOptions: RunnableBatchOptions & {
          returnExceptions: true;
      }

    返回 Promise<(Error | T)[]>

  • 参数

    • inputs: T[]
    • 可选 options: Partial<RunnableConfig<Record<string, any>>> | Partial<RunnableConfig<Record<string, any>>>[]
    • 可选 batchOptions: RunnableBatchOptions

    返回 Promise<(Error | T)[]>

  • 将参数绑定到可运行对象,返回一个新的可运行对象。

    参数

    • kwargs: Partial<RunnableConfig<Record<string, any>>>

    返回 Runnable<T, T, RunnableConfig<Record<string, any>>>

    一个新的 RunnableBinding,在调用时将应用绑定的参数。

  • 参数

    • 可选 _: RunnableConfig<Record<string, any>>

    返回 Graph

  • 参数

    • 可选 suffix: string

    返回 string

  • 参数

    • input: T
    • 可选 options: Partial<RunnableConfig<Record<string, any>>>

    返回 Promise<T>

  • 返回一个新的可运行对象,该对象通过对每个输入调用 invoke() 将输入列表映射到输出列表。

    返回 Runnable<T[], T[], RunnableConfig<Record<string, any>>>

  • 从此可运行对象的字典输出中选取键。返回一个新的可运行对象。

    参数

    • keys: string | string[]

    返回 Runnable<any, any, RunnableConfig<Record<string, any>>>

  • 创建一个新的可运行序列,该序列按顺序运行每个独立的 runnable,将一个 runnable 的输出导入另一个 runnable 或类 runnable 对象。

    类型参数

    • NewRunOutput

    参数

    • coerceable: RunnableLike<T, NewRunOutput, RunnableConfig<Record<string, any>>>

      一个可运行对象、函数或其值是函数或可运行对象的对象。

    返回 Runnable<T, Exclude<NewRunOutput, Error>, RunnableConfig<Record<string, any>>>

    一个新的可运行序列。

  • 参数

    • input: any
    • config: RunnableConfig<Record<string, any>>

    返回 Promise<T>

  • 以块形式流式传输输出。

    参数

    • input: T
    • 可选 options: Partial<RunnableConfig<Record<string, any>>>

    返回 Promise<IterableReadableStream<T>>

    一个可读流,也是一个可迭代对象。

  • 生成由可运行对象的内部步骤发出的事件流。

    用于创建 StreamEvents 的迭代器,提供关于可运行对象进度的实时信息,包括来自中间结果的 StreamEvents。

    StreamEvent 是一个具有以下模式的字典

    • event: string - 事件名称的格式为:on_[runnable_type]_(start|stream|end)。
    • name: string - 生成事件的可运行对象的名称。
    • run_id: string - 与发出事件的可运行对象的给定执行相关联的随机生成ID。作为父可运行对象执行的一部分被调用的子可运行对象会被分配自己的唯一ID。
    • tags: string[] - 生成事件的可运行对象的标签。
    • metadata: Record<string, any> - 生成事件的可运行对象的元数据。
    • data: Record<string, any>

    下表展示了一些可能由各种链发出的事件。元数据字段为简洁起见已从表中省略。链定义已包含在表后。

    注意 此参考表适用于 V2 版本的模式。

    +----------------------+-----------------------------+------------------------------------------+
    | event | input | output/chunk |
    +======================+=============================+==========================================+
    | on_chat_model_start | {"messages": BaseMessage[]} | |
    +----------------------+-----------------------------+------------------------------------------+
    | on_chat_model_stream | | AIMessageChunk("hello") |
    +----------------------+-----------------------------+------------------------------------------+
    | on_chat_model_end | {"messages": BaseMessage[]} | AIMessageChunk("hello world") |
    +----------------------+-----------------------------+------------------------------------------+
    | on_llm_start | {'input': 'hello'} | |
    +----------------------+-----------------------------+------------------------------------------+
    | on_llm_stream | | 'Hello' |
    +----------------------+-----------------------------+------------------------------------------+
    | on_llm_end | 'Hello human!' | |
    +----------------------+-----------------------------+------------------------------------------+
    | on_chain_start | | |
    +----------------------+-----------------------------+------------------------------------------+
    | on_chain_stream | | "hello world!" |
    +----------------------+-----------------------------+------------------------------------------+
    | on_chain_end | [Document(...)] | "hello world!, goodbye world!" |
    +----------------------+-----------------------------+------------------------------------------+
    | on_tool_start | {"x": 1, "y": "2"} | |
    +----------------------+-----------------------------+------------------------------------------+
    | on_tool_end | | {"x": 1, "y": "2"} |
    +----------------------+-----------------------------+------------------------------------------+
    | on_retriever_start | {"query": "hello"} | |
    +----------------------+-----------------------------+------------------------------------------+
    | on_retriever_end | {"query": "hello"} | [Document(...), ..] |
    +----------------------+-----------------------------+------------------------------------------+
    | on_prompt_start | {"question": "hello"} | |
    +----------------------+-----------------------------+------------------------------------------+
    | on_prompt_end | {"question": "hello"} | ChatPromptValue(messages: BaseMessage[]) |
    +----------------------+-----------------------------+------------------------------------------+

    "on_chain_*" 事件是适用于不符合上述任何类别的 Runnables 的默认事件。

    除了上述标准事件外,用户还可以分派自定义事件。

    自定义事件将仅在 API 的 `v2` 版本中显示!

    自定义事件具有以下格式

    +-----------+------+------------------------------------------------------------+
    | Attribute | Type | Description |
    +===========+======+============================================================+
    | name | str | A user defined name for the event. |
    +-----------+------+------------------------------------------------------------+
    | data | Any | The data associated with the event. This can be anything. |
    +-----------+------+------------------------------------------------------------+

    以下是一个例子

    import { RunnableLambda } from "@langchain/core/runnables";
    import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
    // Use this import for web environments that don't support "async_hooks"
    // and manually pass config to child runs.
    // import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch/web";

    const slowThing = RunnableLambda.from(async (someInput: string) => {
    // Placeholder for some slow operation
    await new Promise((resolve) => setTimeout(resolve, 100));
    await dispatchCustomEvent("progress_event", {
    message: "Finished step 1 of 2",
    });
    await new Promise((resolve) => setTimeout(resolve, 100));
    return "Done";
    });

    const eventStream = await slowThing.streamEvents("hello world", {
    version: "v2",
    });

    for await (const event of eventStream) {
    if (event.event === "on_custom_event") {
    console.log(event);
    }
    }

    参数

    • input: T
    • options: Partial<RunnableConfig<Record<string, any>>> & {
          version: "v1" | "v2";
      }
    • 可选的 streamOptions: Omit<EventStreamCallbackHandlerInput, "autoClose">

    返回 IterableReadableStream<StreamEvent>

  • 参数

    • input: T
    • options: Partial<RunnableConfig<Record<string, any>>> & {
          encoding: "text/event-stream";
          version: "v1" | "v2";
      }
    • 可选的 streamOptions: Omit<EventStreamCallbackHandlerInput, "autoClose">

    返回 IterableReadableStream<Uint8Array<ArrayBufferLike>>

  • 流式传输来自可运行对象的所有输出,按照回调系统报告的方式。这包括 LLM、检索器、工具等所有内部运行。输出以日志对象的形式流式传输,其中包括一个 jsonpatch 操作列表,描述了运行状态在每个步骤中如何变化,以及运行的最终状态。jsonpatch 操作可以按顺序应用以构建状态。

    参数

    • input: T
    • 可选 options: Partial<RunnableConfig<Record<string, any>>>
    • 可选的 streamOptions: Omit<LogStreamCallbackHandlerInput, "autoClose">

    返回 AsyncGenerator<RunLogPatch, any, any>

  • 返回 Serialized

  • 返回 SerializedNotImplemented

  • transform 的默认实现,它会缓冲输入,然后调用 stream。如果子类可以在输入仍在生成时开始生成输出,则应覆盖此方法。

    参数

    • generator: AsyncGenerator<T, any, any>
    • options: Partial<RunnableConfig<Record<string, any>>>

    返回 AsyncGenerator<T, any, any>

  • 将配置绑定到 Runnable,返回一个新的 Runnable。

    参数

    • config: RunnableConfig<Record<string, any>>

      要附加到新可运行对象的新配置参数。

    返回 Runnable<T, T, RunnableConfig<Record<string, any>>>

    一个新的 RunnableBinding,其配置与传入的匹配。

  • 从当前可运行对象创建一个新的可运行对象,如果初始调用失败,它将尝试调用其他传入的后备可运行对象。

    参数

    • fields: {
          fallbacks: Runnable<T, T, RunnableConfig<Record<string, any>>>[];
      } | Runnable<T, T, RunnableConfig<Record<string, any>>>[]

    返回 RunnableWithFallbacks<T, T>

    一个新的 RunnableWithFallbacks。

  • 将生命周期监听器绑定到 Runnable,返回一个新的 Runnable。Run 对象包含运行信息,包括其 ID、类型、输入、输出、错误、开始时间、结束时间以及添加到运行的任何标签或元数据。

    参数

    • params: {
          onEnd?: ((run, config?) => void | Promise<void>);
          onError?: ((run, config?) => void | Promise<void>);
          onStart?: ((run, config?) => void | Promise<void>);
      }

      包含回调函数的对象。

      • 可选的 onEnd?: ((run, config?) => void | Promise<void>)

        在可运行对象完成运行后调用,并带上 Run 对象。

          • (run, config?): void | Promise<void>
          • 参数

            • run: Run
            • 可选的 config: RunnableConfig<Record<string, any>>

            返回 void | Promise<void>

      • 可选的 onError?: ((run, config?) => void | Promise<void>)

        如果可运行对象抛出错误,则调用此函数,并带上 Run 对象。

          • (run, config?): void | Promise<void>
          • 参数

            • run: Run
            • 可选的 config: RunnableConfig<Record<string, any>>

            返回 void | Promise<void>

      • 可选的 onStart?: ((run, config?) => void | Promise<void>)

        在可运行对象开始运行前调用,并带上 Run 对象。

          • (run, config?): void | Promise<void>
          • 参数

            • run: Run
            • 可选的 config: RunnableConfig<Record<string, any>>

            返回 void | Promise<void>

    返回 Runnable<T, T, RunnableConfig<Record<string, any>>>

  • 向现有可运行对象添加重试逻辑。

    参数

    • 可选的 fields: {
          onFailedAttempt?: RunnableRetryFailedAttemptHandler;
          stopAfterAttempt?: number;
      }
      • 可选的 onFailedAttempt?: RunnableRetryFailedAttemptHandler
      • 可选的 stopAfterAttempt?: number

    返回 RunnableRetry<T, T, RunnableConfig<Record<string, any>>>

    一个新的 RunnableRetry,在被调用时将根据参数进行重试。

  • 参数

    • thing: any

    返回 thing is Runnable<any, any, RunnableConfig<Record<string, any>>>

  • 可序列化对象的名称。重写此方法以提供别名或在压缩环境中保留序列化模块名称。

    作为静态方法实现以支持加载逻辑。

    返回 string