跳到主要内容
函数式 API 允许您将 LangGraph 的主要功能——持久化内存人工干预流式传输——添加到您的应用程序中,并且对现有代码进行最少的更改。 它旨在将这些功能集成到可能使用标准语言原语进行分支和控制流(例如 if 语句、for 循环和函数调用)的现有代码中。与许多需要将代码重构为显式管道或 DAG 的数据编排框架不同,函数式 API 允许您在不强制执行严格执行模型的情况下整合这些功能。 函数式 API 使用两个关键构建块:
  • entrypoint – 入口点封装了工作流逻辑并管理执行流,包括处理长时间运行的任务和中断。
  • task – 代表一个离散的工作单元,例如 API 调用或数据处理步骤,可以在入口点内异步执行。任务返回一个类似 Future 的对象,可以等待或同步解析。
这为构建具有状态管理和流式传输功能的工作流提供了最少的抽象。
有关如何使用函数式 API 的信息,请参见使用函数式 API

函数式 API 与图 API

对于更喜欢声明式方法的开发人员,LangGraph 的图 API 允许您使用图范例定义工作流。两个 API 共享相同的底层运行时,因此您可以在同一个应用程序中同时使用它们。 以下是一些关键区别:
  • 控制流:函数式 API 不需要考虑图结构。您可以使用标准 Python 构造来定义工作流。这通常会减少您需要编写的代码量。
  • 短期内存图 API 需要声明一个状态,并且可能需要定义reducers来管理对图状态的更新。@entrypoint@tasks 不需要显式状态管理,因为它们的状态作用域限定在函数内,并且不会在函数之间共享。
  • 检查点:两个 API 都生成并使用检查点。在图 API 中,每个超步骤之后都会生成一个新的检查点。在函数式 API 中,当任务执行时,它们的結果會被保存到与给定入口点关联的现有检查点中,而不是创建新的检查点。
  • 可视化:图 API 使得将工作流可视化为图变得容易,这对于调试、理解工作流以及与他人共享非常有用。函数式 API 不支持可视化,因为图是在运行时动态生成的。

示例

下面我们演示了一个简单的应用程序,它编写了一篇文章并中断以请求人工审核。
import { MemorySaver, entrypoint, task, interrupt } from "@langchain/langgraph";

const writeEssay = task("writeEssay", async (topic: string) => {
  // A placeholder for a long-running task.
  await new Promise((resolve) => setTimeout(resolve, 1000));
  return `An essay about topic: ${topic}`;
});

const workflow = entrypoint(
  { checkpointer: new MemorySaver(), name: "workflow" },
  async (topic: string) => {
    const essay = await writeEssay(topic);
    const isApproved = interrupt({
      // Any json-serializable payload provided to interrupt as argument.
      // It will be surfaced on the client side as an Interrupt when streaming data
      // from the workflow.
      essay, // The essay we want reviewed.
      // We can add any additional information that we need.
      // For example, introduce a key called "action" with some instructions.
      action: "Please approve/reject the essay",
    });

    return {
      essay, // The essay that was generated
      isApproved, // Response from HIL
    };
  }
);
此工作流将撰写一篇关于“猫”的文章,然后暂停以获取人工审核。工作流可以无限期地中断,直到提供审核。当工作流恢复时,它从头开始执行,但由于 writeEssay 任务的结果已保存,任务结果将从检查点加载而不是重新计算。
import { v4 as uuidv4 } from "uuid";
import { MemorySaver, entrypoint, task, interrupt } from "@langchain/langgraph";

const writeEssay = task("writeEssay", async (topic: string) => {
  // This is a placeholder for a long-running task.
  await new Promise(resolve => setTimeout(resolve, 1000));
  return `An essay about topic: ${topic}`;
});

const workflow = entrypoint(
  { checkpointer: new MemorySaver(), name: "workflow" },
  async (topic: string) => {
    const essay = await writeEssay(topic);
    const isApproved = interrupt({
      // Any json-serializable payload provided to interrupt as argument.
      // It will be surfaced on the client side as an Interrupt when streaming data
      // from the workflow.
      essay, // The essay we want reviewed.
      // We can add any additional information that we need.
      // For example, introduce a key called "action" with some instructions.
      action: "Please approve/reject the essay",
    });

    return {
      essay, // The essay that was generated
      isApproved, // Response from HIL
    };
  }
);

const threadId = uuidv4();

const config = {
  configurable: {
    thread_id: threadId
  }
};

for await (const item of workflow.stream("cat", config)) {
  console.log(item);
}
{ writeEssay: 'An essay about topic: cat' }
{
  __interrupt__: [{
    value: { essay: 'An essay about topic: cat', action: 'Please approve/reject the essay' },
    resumable: true,
    ns: ['workflow:f7b8508b-21c0-8b4c-5958-4e8de74d2684'],
    when: 'during'
  }]
}
文章已撰写完成并可供审核。一旦提供审核,我们就可以恢复工作流。
import { Command } from "@langchain/langgraph";

// Get review from a user (e.g., via a UI)
// In this case, we're using a bool, but this can be any json-serializable value.
const humanReview = true;

for await (const item of workflow.stream(new Command({ resume: humanReview }), config)) {
  console.log(item);
}
{ workflow: { essay: 'An essay about topic: cat', isApproved: true } }
工作流已完成,审核已添加到文章中。

入口点

entrypoint 函数可用于从函数创建工作流。它封装了工作流逻辑并管理执行流,包括处理长时间运行的任务中断

定义

通过调用带有配置和函数的 entrypoint 函数来定义入口点 该函数必须接受一个单独的位置参数,该参数用作工作流输入。如果您需要传递多个数据,请使用对象作为第一个参数的输入类型。 使用函数创建入口点会生成一个工作流实例,有助于管理工作流的执行(例如,处理流式传输、恢复和检查点)。 您通常会希望将检查点器传递给 entrypoint 函数以启用持久性并使用人工干预等功能。
import { entrypoint } from "@langchain/langgraph";

const myWorkflow = entrypoint(
  { checkpointer, name: "workflow" },
  async (someInput: Record<string, any>): Promise<number> => {
    // some logic that may involve long-running tasks like API calls,
    // and may be interrupted for human-in-the-loop
    return result;
  }
);
序列化 入口点的输入输出必须是 JSON 可序列化的,以支持检查点。请参阅序列化部分了解更多详细信息。

执行

使用entrypoint函数将返回一个对象,该对象可以使用invokestream方法执行。
  • 调用
  • 流式处理
const config = {
  configurable: {
    thread_id: "some_thread_id"
  }
};
await myWorkflow.invoke(someInput, config); // Wait for the result

恢复

中断后恢复执行可以通过将resume值传递给Command原语来完成。
  • 调用
  • 流式处理
import { Command } from "@langchain/langgraph";

const config = {
  configurable: {
    thread_id: "some_thread_id"
  }
};

await myWorkflow.invoke(new Command({ resume: someResumeValue }), config);
错误后恢复 要从错误中恢复,请使用 null 和相同的线程 ID(配置)运行 entrypoint 这假设底层错误已解决,并且执行可以成功进行。
  • 调用
  • 流式处理
const config = {
  configurable: {
    thread_id: "some_thread_id"
  }
};

await myWorkflow.invoke(null, config);

短期记忆

当使用 checkpointer 定义 entrypoint 时,它会在相同线程 ID 上的连续调用之间将信息存储在检查点中。 这允许使用 getPreviousState 函数访问上一次调用的状态。 默认情况下,getPreviousState 函数返回上一次调用的返回值。
import { entrypoint, getPreviousState } from "@langchain/langgraph";

const myWorkflow = entrypoint(
  { checkpointer, name: "workflow" },
  async (number: number) => {
    const previous = getPreviousState<number>() ?? 0;
    return number + previous;
  }
);

const config = {
  configurable: {
    thread_id: "some_thread_id",
  },
};

await myWorkflow.invoke(1, config); // 1 (previous was undefined)
await myWorkflow.invoke(2, config); // 3 (previous was 1 from the previous invocation)

entrypoint.final

entrypoint.final 是一个特殊原语,可以从入口点返回,并允许将保存在检查点中的值入口点的返回值进行解耦 第一个值是入口点的返回值,第二个值是保存在检查点中的值。
import { entrypoint, getPreviousState } from "@langchain/langgraph";

const myWorkflow = entrypoint(
  { checkpointer, name: "workflow" },
  async (number: number) => {
    const previous = getPreviousState<number>() ?? 0;
    // This will return the previous value to the caller, saving
    // 2 * number to the checkpoint, which will be used in the next invocation
    // for the `previous` parameter.
    return entrypoint.final({
      value: previous,
      save: 2 * number,
    });
  }
);

const config = {
  configurable: {
    thread_id: "1",
  },
};

await myWorkflow.invoke(3, config); // 0 (previous was undefined)
await myWorkflow.invoke(1, config); // 6 (previous was 3 * 2 from the previous invocation)

任务

任务代表一个离散的工作单元,例如 API 调用或数据处理步骤。它具有两个关键特性:
  • 异步执行:任务设计为异步执行,允许多个操作并发运行而不阻塞。
  • 检查点:任务结果保存到检查点,从而能够从上次保存的状态恢复工作流。(有关更多详细信息,请参阅持久化)。

定义

任务使用 task 函数定义,该函数封装了一个常规函数。
import { task } from "@langchain/langgraph";

const slowComputation = task("slowComputation", async (inputValue: any) => {
  // Simulate a long-running operation
  return result;
});
序列化 任务的输出必须是 JSON 可序列化的,以支持检查点。

执行

任务只能在入口点、另一个任务状态图节点中调用。 任务不能直接从主应用程序代码中调用。 当您调用一个任务时,它会返回一个可以被等待的 Promise。
const myWorkflow = entrypoint(
  { checkpointer, name: "workflow" },
  async (someInput: number): Promise<number> => {
    return await slowComputation(someInput);
  }
);

何时使用任务

任务在以下场景中非常有用:
  • 检查点:当您需要将长时间运行操作的结果保存到检查点时,这样在恢复工作流时就不需要重新计算它。
  • 人工干预:如果您正在构建一个需要人工干预的工作流,您必须使用任务来封装任何随机性(例如,API 调用),以确保工作流可以正确恢复。有关更多详细信息,请参阅确定性部分。
  • 并行执行:对于 I/O 密集型任务,任务支持并行执行,允许多个操作并发运行而不阻塞(例如,调用多个 API)。
  • 可观察性:将操作封装在任务中提供了一种使用 LangSmith 跟踪工作流进度和监控单个操作执行的方法。
  • 可重试工作:当需要重试工作以处理故障或不一致时,任务提供了一种封装和管理重试逻辑的方法。

序列化

LangGraph 中的序列化有两个关键方面:
  1. entrypoint 的输入和输出必须是 JSON 可序列化的。
  2. task 的输出必须是 JSON 可序列化的。
这些要求是启用检查点和工作流恢复所必需的。使用对象、数组、字符串、数字和布尔值等基本类型来确保您的输入和输出是可序列化的。 序列化确保工作流状态(例如任务结果和中间值)可以可靠地保存和恢复。这对于实现人工干预、容错和并行执行至关重要。 提供不可序列化的输入或输出将导致工作流配置检查点时出现运行时错误。

确定性

为了利用人工干预等功能,任何随机性都应封装在任务中。这保证了当执行暂停(例如,用于人工干预)然后恢复时,即使任务结果不确定,它也将遵循相同的步骤序列 LangGraph 通过在执行时持久化任务子图结果来实现此行为。精心设计的工作流确保恢复执行遵循相同的步骤序列,从而可以正确检索先前计算的结果,而无需重新执行它们。这对于长时间运行的任务或结果不确定的任务特别有用,因为它避免了重复先前完成的工作,并允许从本质上相同的地方恢复。 虽然工作流的不同运行可以产生不同的结果,但恢复特定运行应始终遵循相同的记录步骤序列。这使得 LangGraph 能够高效地查找在图被中断之前执行的任务子图结果,并避免重新计算它们。

幂等性

幂等性确保多次运行相同的操作会产生相同的结果。这有助于防止在由于失败而重新运行某个步骤时出现重复的 API 调用和冗余处理。始终将 API 调用放在任务函数中以进行检查点,并将其设计为幂等,以防重新执行。如果任务启动但未成功完成,则可能会发生重新执行。然后,如果工作流恢复,任务将再次运行。使用幂等键或验证现有结果以避免重复。

常见陷阱

处理副作用

将副作用(例如,写入文件、发送电子邮件)封装在任务中,以确保在恢复工作流时它们不会多次执行。
  • 不正确
  • 正确
在此示例中,副作用(写入文件)直接包含在工作流中,因此在恢复工作流时它将再次执行。
import { entrypoint, interrupt } from "@langchain/langgraph";
import fs from "fs";

const myWorkflow = entrypoint(
  { checkpointer, name: "workflow },
  async (inputs: Record<string, any>) => {
    // This code will be executed a second time when resuming the workflow.
    // Which is likely not what you want.
    fs.writeFileSync("output.txt", "Side effect executed");
    const value = interrupt("question");
    return value;
  }
);

非确定性控制流

每次可能给出不同结果的操作(如获取当前时间或随机数)应封装在任务中,以确保在恢复时返回相同的结果。
  • 在任务中:获取随机数 (5) → 中断 → 恢复 → (再次返回 5) → …
  • 不在任务中:获取随机数 (5) → 中断 → 恢复 → 获取新随机数 (7) → …
当使用包含多次中断调用的人工干预工作流时,这一点尤其重要。LangGraph 为每个任务/入口点保留一个恢复值列表。当遇到中断时,它会与相应的恢复值匹配。此匹配严格基于索引,因此恢复值的顺序应与中断的顺序匹配。 如果在恢复时未保持执行顺序,则一次interrupt调用可能会与错误的resume值匹配,从而导致不正确的结果。 请阅读有关确定性的部分以获取更多详细信息。
  • 不正确
  • 正确
在此示例中,工作流使用当前时间来确定要执行哪个任务。这是非确定性的,因为工作流的结果取决于其执行时间。
import { entrypoint, interrupt } from "@langchain/langgraph";

const myWorkflow = entrypoint(
  { checkpointer, name: "workflow" },
  async (inputs: { t0: number }) => {
    const t1 = Date.now();

    const deltaT = t1 - inputs.t0;

    if (deltaT > 1000) {
      const result = await slowTask(1);
      const value = interrupt("question");
      return { result, value };
    } else {
      const result = await slowTask(2);
      const value = interrupt("question");
      return { result, value };
    }
  }
);

以编程方式连接这些文档到 Claude、VSCode 等,通过 MCP 获取实时答案。
© . This site is unofficial and not affiliated with LangChain, Inc.