Memory ↗

const memory = new MemorySaver();

// We will add a summary attribute (in addition to messages key) const GraphState = new StateSchema({ messages: MessagesValue, summary: z.string().default(""), });

// We will use this model for both the conversation and the summarization const model = new ChatAnthropic({ model: “claude-haiku-4-5-20251001” });

// Define the logic to call the model const callModel: GraphNode = async (state) => { // If a summary exists, we add this in as a system message const { summary } = state; let { messages } = state; if (summary) { const systemMessage = new SystemMessage({ id: uuidv4(), content: Summary of conversation earlier: ${summary}, }); messages = [systemMessage, …messages]; } const response = await model.invoke(messages); // We return an object, because this will get added to the existing state return { messages: [response] }; };

// We now define the logic for determining whether to end or summarize the conversation const shouldContinue: ConditionalEdgeRouter<typeof GraphState, “summarize_conversation”> = (state) => { const messages = state.messages; // If there are more than six messages, then we summarize the conversation if (messages.length > 6) { return “summarize_conversation”; } // Otherwise we can just end return END; };

const summarizeConversation: GraphNode = async (state) => { // First, we summarize the conversation const { summary, messages } = state; let summaryMessage: string; if (summary) { // If a summary already exists, we use a different system prompt // to summarize it than if one didn’t summaryMessage = This is summary of the conversation to date: ${summary}\n\n + “Extend the summary by taking into account the new messages above:”; } else { summaryMessage = “Create a summary of the conversation above:”; }

const allMessages = [
  ...messages,
  new HumanMessage({ id: uuidv4(), content: summaryMessage }),
];

const response = await model.invoke(allMessages);

// We now need to delete messages that we no longer want to show up
// I will delete all but the last two messages, but you can change this
const deleteMessages = messages
  .slice(0, -2)
  .map((m) => new RemoveMessage({ id: m.id! }));

if (typeof response.content !== "string") {
  throw new Error("Expected a string response from the model");
}

return { summary: response.content, messages: deleteMessages };

};

// Define a new graph const workflow = new StateGraph(GraphState) // Define the conversation node and the summarize node .addNode(“conversation”, callModel) .addNode(“summarize_conversation”, summarizeConversation) // Set the entrypoint as conversation .addEdge(START, “conversation”) // We now add a conditional edge .addConditionalEdges( // First, we define the start node. We use conversation. // This means these are the edges taken after the conversation node is called. “conversation”, // Next, we pass in the function that will determine which node is called next. shouldContinue, ) // We now add a normal edge from summarize_conversation to END. // This means that after summarize_conversation is called, we end. .addEdge(“summarize_conversation”, END);

// Finally, we compile it! const app = workflow.compile({ checkpointer: memory });

</Accordion>

### Manage checkpoints

You can view and delete the information stored by the checkpointer.

<a id="checkpoint" />

#### View thread state

```typescript
const config = {
configurable: {
  thread_id: "1",
  // optionally provide an ID for a specific checkpoint,
  // otherwise the latest checkpoint is shown
  // checkpoint_id: "1f029ca3-1f5b-6704-8004-820c16b69a5a"
},
};
await graph.getState(config);

{
  values: { messages: [HumanMessage(...), AIMessage(...), HumanMessage(...), AIMessage(...)] },
  next: [],
  config: { configurable: { thread_id: '1', checkpoint_ns: '', checkpoint_id: '1f029ca3-1f5b-6704-8004-820c16b69a5a' } },
  metadata: {
    source: 'loop',
    writes: { call_model: { messages: AIMessage(...) } },
    step: 4,
    parents: {},
    thread_id: '1'
  },
  createdAt: '2025-05-05T16:01:24.680462+00:00',
  parentConfig: { configurable: { thread_id: '1', checkpoint_ns: '', checkpoint_id: '1f029ca3-1790-6b0a-8003-baf965b6a38f' } },
  tasks: [],
  interrupts: []
}

View the history of the thread#

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

const history = [];
for await (const state of graph.getStateHistory(config)) {
  history.push(state);
}

Delete all checkpoints for a thread#

const threadId = "1";
await checkpointer.deleteThread(threadId);

Database management#

If you are using any database-backed persistence implementation (such as Postgres or Redis) to store short and/or long-term memory, you will need to run migrations to set up the required schema before you can use it with your database.

By convention, most database-specific libraries define a setup() method on the checkpointer or store instance that runs the required migrations. However, you should check with your specific implementation of BaseCheckpointSaver or BaseStore to confirm the exact method name and usage.

We recommend running migrations as a dedicated deployment step, or you can ensure they’re run as part of server startup.

Edit this page on GitHub or file an issue.

Connect these docs to Claude, VSCode, and more via MCP for real-time answers.