Where does the new MemorySaver() of @langchain/langgraph actually store the chat history ?

[DevDeepakBhattarai]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import {
  AIMessage,
  type BaseMessage,
  ToolMessage,
  HumanMessage,
  type AIMessageChunk,
  FunctionMessage,
} from "@langchain/core/messages";
import { type RunnableConfig } from "@langchain/core/runnables";
import { StateGraph, START, END, MemorySaver } from "@langchain/langgraph";
import {
  ChatPromptTemplate,
  MessagesPlaceholder,
} from "@langchain/core/prompts";
import { ChatOpenAI } from "@langchain/openai";
import { type StructuredToolInterface } from "@langchain/core/tools";
import { search_tool } from "./tools/search";
import { type AvailableModels, modelPicker } from "@/lib/modelPicker";
import { suggestion } from "./tools/suggestion";
import { env } from "@/env";
import { ConversationSummaryBufferMemory } from "langchain/memory";
import { redis } from "@/lib/redis";
import { UpstashRedisChatMessageHistory } from "@langchain/community/stores/message/upstash_redis";
import { weatherTool } from "./tools/weather";
import { OUTPUT_MODEL } from "../utils/server";
import { safeJsonParse } from "@/lib/utils";
import { crypto_tool } from "./tools/crypto";
import { format } from "date-fns";


const memory = new ConversationSummaryBufferMemory({
  memoryKey: "history",
  maxTokenLimit: 300,
  llm: new ChatOpenAI({
    model: "gpt-3.5-turbo",
    temperature: 0,
    apiKey: env.OPENAI_API_KEY,
  }),
});

export interface AgentExecutorState {
  input: BaseMessage[];
  model: AvailableModels;
  chat_history: BaseMessage[];
  objective: string;
  chatId: string;
  userId: string;
  /**
   * The plain text result of the LLM if
   * no tool was used.
   */
  result?: string;
  /**
   * The parsed tool result that was called.
   */
  toolCall?: {
    name: string;
    parameters: Record<string, unknown>;
    id: string;
  };
  /**
   * The result of a tool.
   */
  toolResult?: Record<string, unknown>;
  existingSummary: string;
}

const checkPointer = new MemorySaver();
const invokeModel = async (
  state: AgentExecutorState,
  config?: RunnableConfig,
  ...args
): Promise<Partial<AgentExecutorState>> => {
  console.log(config);
  console.log(args);
  const initialPrompt =
    state.model !== "groq" ? promptWithImage : promptWithoutImages;
  const MessageHistoryStore = new UpstashRedisChatMessageHistory({
    sessionId: `${state.userId}-chat-${state.chatId}`, // Or some other unique identifier for the conversation
    client: redis,
  });

  const tools = [search_tool, weatherTool, crypto_tool];
  const llm = modelPicker(state.model, true)
    .bindTools(tools)
    .withConfig({ runName: OUTPUT_MODEL });
  const chain = initialPrompt.pipe(llm);

  let result: AIMessageChunk | undefined = undefined;
  result = await chain.invoke(state, config);

  if (!result) {
    return {
      result: "Sorry there was an error",
    };
  }

  if (
    state.model === "gemini" &&
    result.additional_kwargs.tool_calls &&
    result.additional_kwargs.tool_calls.length > 0
  ) {
    const tool_call = result.additional_kwargs.tool_calls[0]!;
    const toolCall = {
      name: tool_call.function.name,
      parameters: safeJsonParse(tool_call.function.arguments)!,
      id: tool_call.id ?? "",
    };
    return {
      toolCall,
      chat_history: [result],
    };
  }

  if (result.tool_calls && result.tool_calls.length > 0) {
    const toolCall = {
      name: result.tool_calls[0]!.name,
      parameters: result.tool_calls[0]!.args,
      id: result.tool_calls[0]!.id ?? "",
    };
    return {
      toolCall,
      chat_history: [result],
    };
  }

  result.content &&
    void MessageHistoryStore.addAIMessage(result.content as string);

  const newSummary = await memory.predictNewSummary(
    [
      new HumanMessage(state.objective),
      new AIMessage(result.content as string),
    ],
    state.existingSummary,
  );
  void redis.set(`${state.userId}-summary-${state.chatId}`, newSummary);

  return {
    result: result.content as string,
    chat_history: [result],
    toolCall: undefined,
  };
};

export function agentExecutor() {
  const workflow = new StateGraph<AgentExecutorState>({
    channels: {
      input: null,
      chat_history: {
        value: (a, b) => a.concat(b),
      },
      result: null,
      toolCall: null,
      toolResult: null,

      objective: null,
      model: null,
      chatId: null,
      userId: null,
      existingSummary: null,
    },
  })
    .addNode("invokeModel", invokeModel)
    .addNode("invokeIntermediateTools", invokeTools)
    .addNode("invokeResponseTools", invokeTools)
    .addNode("generate_suggestion", suggestion)
    .addEdge(START, "invokeModel")
    .addConditionalEdges("invokeModel", invokeToolsOrReturn)
    .addEdge("invokeIntermediateTools", "invokeModel")
    .addEdge("invokeResponseTools", END)
    .addEdge("generate_suggestion", END);

  const graph = workflow.compile();
  return graph;
}

Description

I am trying to build a Chatbot with tool calling support using Langgraph. I am currently using the ConversationSummaryBufferMemory to summarize and store my messages in Upstash Redis. How can I change this approach use the Persistence feature of Langgraph.

Is saving my chat history in Redis even possible using Langgraph persistence feature.
It would be great if someone could help me

System Info

pnpm 9.4.0
node 18
window 10

[dosubot[bot]]

The MemorySaver class in @langchain/langgraph does not directly handle the storage of chat history. Instead, it acts as a wrapper around ChatMessageHistory to manage and persist chat messages. To store chat history in Redis using the persistence feature of Langgraph, you can use the UpstashRedisChatMessageHistory class from @langchain/community/stores/message/upstash_redis.

Here's an example of how to configure and use MemorySaver with Redis:

import { Redis } from "@upstash/redis";
import { BufferMemory } from "langchain/memory";
import { UpstashRedisChatMessageHistory } from "@langchain/community/stores/message/upstash_redis";
import { ChatOpenAI } from "langchain/openai";
import { ConversationChain } from "langchain/chains";

// Create your own Redis client
const client = new Redis({
  url: "https://ADD_YOURS_HERE.upstash.io",
  token: "********",
});

const memory = new BufferMemory({
  chatHistory: new UpstashRedisChatMessageHistory({
    sessionId: new Date().toISOString(),
    sessionTTL: 300,
    client, // You can reuse your existing Redis client
  }),
});

const model = new ChatOpenAI({
  model: "gpt-3.5-turbo",
  temperature: 0,
});

const chain = new ConversationChain({ llm: model, memory });

const res1 = await chain.invoke({ input: "Hi! I'm Jim." });
console.log({ res1 });

const res2 = await chain.invoke({ input: "What did I just say my name was?" });
console.log({ res2 });

In this example:

• A Redis client is created using the @upstash/redis package.
• The BufferMemory class is configured with UpstashRedisChatMessageHistory, which uses the Redis client for storing chat history.
• The sessionId and sessionTTL options are set to manage session details.
• The ConversationChain is then created using the configured memory and a language model.

This setup allows you to store and retrieve chat history in Redis using the persistence feature of Langgraph ^[1].

To continue talking to Dosu, mention @dosu.

[DevDeepakBhattarai]

There is no use of MemorySaver() in the above code. Can you provide me an actual example @dosu

[dosubot[bot]]

To use MemorySaver with Redis in Langgraph, you can follow this example. This demonstrates how to integrate MemorySaver with UpstashRedisChatMessageHistory to store chat history in Redis.

import { Redis } from "@upstash/redis";
import { MemorySaver } from "@langchain/langgraph";
import { UpstashRedisChatMessageHistory } from "@langchain/community/stores/message/upstash_redis";
import { ChatOpenAI } from "langchain/openai";
import { ConversationChain } from "langchain/chains";

// Create your own Redis client
const client = new Redis({
  url: "https://ADD_YOURS_HERE.upstash.io",
  token: "********",
});

// Configure MemorySaver with UpstashRedisChatMessageHistory
const memory = new MemorySaver({
  chatHistory: new UpstashRedisChatMessageHistory({
    sessionId: new Date().toISOString(), // Unique identifier for the conversation
    sessionTTL: 300, // 5 minutes, omit this parameter to make sessions never expire
    client, // Reuse your existing Redis client
  }),
});

const model = new ChatOpenAI({
  model: "gpt-3.5-turbo",
  temperature: 0,
});

const chain = new ConversationChain({ llm: model, memory });

const res1 = await chain.invoke({ input: "Hi! I'm Jim." });
console.log({ res1 });

const res2 = await chain.invoke({ input: "What did I just say my name was?" });
console.log({ res2 });

In this example:

• A Redis client is created using the @upstash/redis package.
• The MemorySaver class is configured with UpstashRedisChatMessageHistory, which uses the Redis client for storing chat history.
• The sessionId and sessionTTL options are set to manage session details.
• The ConversationChain is then created using the configured memory and a language model.

This setup allows you to store and retrieve chat history in Redis using the persistence feature of Langgraph ^[1].

To continue talking to Dosu, mention @dosu.