END of graph ignored in agent-chat-ui?

[beepsoft]

I am struggling to understand the relation between running a graph and running a graph via agent-chat-ui in a thread. Take the following simple chat graph:

import {
  Annotation, END,
  MessagesAnnotation,
  START,
  StateGraph
} from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

const ChatAgentAnnotation = Annotation.Root({
  messages: MessagesAnnotation.spec["messages"],
});

const graph = new StateGraph(ChatAgentAnnotation)
  .addNode("chat", async (state) => {
    const model = new ChatOpenAI({
      model: "gpt-4o-mini",
    });

    const response = await model.invoke([
      { role: "system", content: "You are a helpful assistant." },
      ...state.messages,
    ]);

    return {
      messages: response,
    };
  })
  .addEdge(START, "chat")
  .addEdge("chat", END);

export const agent = graph.compile();
agent.name = "Chat Agent";

If this was executed by hand (say, from a notebook), providing the input for the the "chat" node, this graph would end with the AI's reponse.

However, if I run this using langgraph platform and the agent-chat-ui, the execution continues infinitely and it remembers all previous messages, although there's an explicit END to the graph. I would expect that once the graph is END-ed it resets its state so that when I give it the 2nd or 3rd user input it would not remember previous messages. However, it does:

I expected that to the "What is my name?" question it would not give the correct answer as the previous graph has ended. However, it has the same messages in state and it answers correctly.

So, what is going on here? How are threads relate to graph execution and state?

[hinthornw]

Each invocation starts the graph anew. Using the same thread loads the last checkpoint from the previous execution of that thread.

See: https://langchain-ai.github.io/langgraph/concepts/memory/
and https://langchain-ai.github.io/langgraph/concepts/persistence/

[beepsoft]

Thanks @hinthornw for the links! I already went through these, but somehow didn't connect the "short term memory" concept with this behaviour and that subsequent invocations of the same graph will inherit the state of the previous invocations.

[hinthornw]

What would you expect the behavior to be? Never execute again?

[beepsoft]

No, It is OK now, but I just had to understand the relation between a graph's END state and its relation to how threads work. This was somehow not obvious form the docs and examples.

Most of the examples I found are agents run from cli or notebook and naturally they finish at the END node and if you run them again, they start from a fresh/empty state. Then when I started to work with agents run from agent-chat-ui I got confused, but now I get the idea.