Function entrypoint

Define a LangGraph workflow using the entrypoint function.

Function signature

The wrapped function must accept at most two parameters. The first parameter is the input to the function. The second (optional) parameter is a LangGraphRunnableConfig object. If you wish to pass multiple parameters to the function, you can pass them as an object.

Helper functions

Streaming

To write data to the "custom" stream, use the getWriter function, or the LangGraphRunnableConfig.writer property.

State management

The getPreviousState function can be used to access the previous state that was returned from the last invocation of the entrypoint on the same thread id.

If you wish to save state other than the return value, you can use the entrypoint.final function.

Example: Using entrypoint and tasks

import { task, entrypoint } from "@langchain/langgraph";
import { MemorySaver } from "@langchain/langgraph-checkpoint";
import { interrupt, Command } from "@langchain/langgraph";

const composeEssay = task("compose", async (topic: string) => {
  await new Promise(r => setTimeout(r, 1000)); // Simulate slow operation
  return `An essay about ${topic}`;
});

const reviewWorkflow = entrypoint({
  name: "review",
  checkpointer: new MemorySaver()
}, async (topic: string) => {
  const essay = await composeEssay(topic);
  const humanReview = await interrupt({
    question: "Please provide a review",
    essay
  });
  return {
    essay,
    review: humanReview
  };
});

// Example configuration for the workflow
const config = {
  configurable: {
    thread_id: "some_thread"
  }
};

// Topic for the essay
const topic = "cats";

// Stream the workflow to generate the essay and await human review
for await (const result of reviewWorkflow.stream(topic, config)) {
  console.log(result);
}

// Example human review provided after the interrupt
const humanReview = "This essay is great.";

// Resume the workflow with the provided human review
for await (const result of reviewWorkflow.stream(new Command({ resume: humanReview }), config)) {
  console.log(result);
}

Example: Accessing the previous return value

import { entrypoint, getPreviousState } from "@langchain/langgraph";
import { MemorySaver } from "@langchain/langgraph-checkpoint";

const accumulator = entrypoint({
  name: "accumulator",
  checkpointer: new MemorySaver()
}, async (input: string) => {
  const previous = getPreviousState<number>();
  return previous !== undefined ? `${previous } ${input}` : input;
});

const config = {
  configurable: {
    thread_id: "some_thread"
  }
};
await accumulator.invoke("hello", config); // returns "hello"
await accumulator.invoke("world", config); // returns "hello world"

Example: Using entrypoint.final to save a value

import { entrypoint, getPreviousState } from "@langchain/langgraph";
import { MemorySaver } from "@langchain/langgraph-checkpoint";

const myWorkflow = entrypoint({
  name: "accumulator",
  checkpointer: new MemorySaver()
}, async (num: number) => {
  const previous = getPreviousState<number>();

  // This will return the previous value to the caller, saving
  // 2 * num to the checkpoint, which will be used in the next invocation
  // for the `previous` parameter.
  return entrypoint.final({
    value: previous ?? 0,
    save: 2 * num
  });
});

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

await myWorkflow.invoke(3, config); // 0 (previous was undefined)
await myWorkflow.invoke(1, config); // 6 (previous was 3 * 2 from the previous invocation)
  • entrypoint<InputT, OutputT>(
        optionsOrName: string | EntrypointOptions,
        func: OutputT extends AsyncGenerator<unknown, unknown, unknown>
            ? never
            : OutputT extends Generator<unknown, unknown, unknown>
                ? never
                : (input: InputT, config: LangGraphRunnableConfig) => OutputT,
    ): Pregel<
        Record<string, PregelNode<InputT, EntrypointReturnT<OutputT>>>,
        {
            __end__: LastValue<EntrypointReturnT<OutputT>>;
            __previous__: LastValue<EntrypointFinalSaveT<OutputT>>;
            __start__: EphemeralValue<InputT>;
        },
        Record<string, unknown>,
        InputT,
        EntrypointReturnT<OutputT>,
    >

    Type Parameters

    • InputT

      The type of input the entrypoint accepts

    • OutputT

      The type of output the entrypoint produces

    Parameters

    Returns Pregel<
        Record<string, PregelNode<InputT, EntrypointReturnT<OutputT>>>,
        {
            __end__: LastValue<EntrypointReturnT<OutputT>>;
            __previous__: LastValue<EntrypointFinalSaveT<OutputT>>;
            __start__: EphemeralValue<InputT>;
        },
        Record<string, unknown>,
        InputT,
        EntrypointReturnT<OutputT>,
    >

    A Pregel instance that can be run to execute the workflow

Methods

final

Methods

final

  • final<ValueT, SaveT>(
        options: { save?: SaveT; value?: ValueT },
    ): EntrypointFinal<ValueT, SaveT>

    A helper utility for use with the functional API that returns a value to the caller, as well as a separate state value to persist to the checkpoint. This allows workflows to maintain state between runs while returning different values to the caller.

    Type Parameters

    • ValueT

      The type of the value to return to the caller

    • SaveT

      The type of the state to save to the checkpoint

    Parameters

    Returns EntrypointFinal<ValueT, SaveT>

    An object with the value and save properties

    Example

    return entrypoint.final({
      value: "result for caller",
      save: { counter: currentCount + 1 }
    });

Settings

Member Visibility

On This Page

Function signatureHelper functions
Methods