Why can't the AI remember my name after I told him?

[Elindo586]

How can I applied memory to the conversation so it knows what I just told him?

I am using Next.js

Conversation:

"I am Jack"
k (4) is greater than the number of elements in the index (1), setting k to 1
k (4) is greater than the number of elements in the index (1), setting k to 1
{ text: 'Hello Jack! How can I assist you today?' }
"What is my name?"
k (4) is greater than the number of elements in the index (1), setting k to 1
k (4) is greater than the number of elements in the index (1), setting k to 1
{
  text: 'The text does not provide the name of the person in the conversation.'
}
"I am Jack"
k (4) is greater than the number of elements in the index (1), setting k to 1
k (4) is greater than the number of elements in the index (1), setting k to 1
{ text: 'Hello Jack! How can I assist you today?' }
"What is my name?"
k (4) is greater than the number of elements in the index (1), setting k to 1
k (4) is greater than the number of elements in the index (1), setting k to 1
{
  text: 'The text does not provide the name of any person in the conversation.'
}

Code is here:

import { ChatOpenAI } from "langchain/chat_models/openai";
import { ConversationalRetrievalQAChain } from "langchain/chains";
import { BufferMemory } from "langchain/memory";

import { TextLoader } from "langchain/document_loaders/fs/text";
import { CharacterTextSplitter } from "langchain/text_splitter";
import { OpenAIEmbeddings } from "langchain/embeddings/openai";
import { FaissStore } from "langchain/vectorstores/faiss";

import { OpenAI } from "langchain/llms/openai";
import { PromptTemplate } from "langchain/prompts";
import {
  SimpleSequentialChain,
  LLMChain,
  RetrievalQAChain,
  loadQAStuffChain,
} from "langchain/chains";

let chain;
let result;

let loader;
let docs;
let splitter;
let documents;
let embeddings1;
let vectorstore;

let model1;

let embeddings;
let vectoreStore;
let vectorStoreRetriever;
let vectorChain;
// let overallChain;

const useStore = async (req, res) => {
  if (req.method === "POST") {
    loader = new TextLoader("./documents/restaurant.txt");
    docs = await loader.load();
    splitter = new CharacterTextSplitter({
      chunkSize: 200,
      chunkOverlap: 50,
    });
    documents = await splitter.splitDocuments(docs);
    embeddings1 = new OpenAIEmbeddings();
    vectorstore = await FaissStore.fromDocuments(documents, embeddings1);
    await vectorstore.save("./");

    const message = req.body.newText;
    const firstOne = req.body.firstMsg;

    console.log(message);
    if (firstOne) {
      model1 = new ChatOpenAI({
        modelName: "gpt-4",
        openAIApiKey: process.env.OPENAI_API_KEY,
        temperature: 0,
      });

      embeddings = new OpenAIEmbeddings();
      vectoreStore = await FaissStore.load("./", embeddings);

      chain = ConversationalRetrievalQAChain.fromLLM(
        model1,
        vectoreStore.asRetriever(),
        {
          memory: new BufferMemory({
            memoryKey: "chat_history", // Must be set to "chat_history"
            inputKey: "question", // The key for the input to the chain
            outputKey: "text", // The key for the final conversational output of the chain
            returnMessages: true,
            // questionGeneratorChainOptions: {
            //   llm: fasterModel,
            // },
          }),
        }
      );
    }

    result = await chain.call({
      question: message,
      chat_history: "",
      // Add the new user message here
      // { role: 'user', content: message },
    });
    const chatHistory = `${message}\n${result.text}`;
    const followUpRes = await chain.call({
      question: "Was that nice?",
      chat_history: chatHistory,
    });

    console.log(result);

    return res.status(200).json({ output: result });
  } else {
    res.status(405).json({ say: "Only POST is allowed" });
  }
};
export default useStore;

[dosubot[bot]]

🤖

Hello,

From your code, it seems like you're using the BufferMemory class to store the chat history. However, it appears that the chat history is not being updated correctly after each interaction. This could be why the AI is unable to remember the user's name.

In your chain.call method, you're passing an empty string for chat_history. Instead, you should pass the previous chat history. Here's how you can do it:

let chatHistory = '';

// First interaction
result = await chain.call({
  question: message,
  chat_history: chatHistory,
});

chatHistory += `${message}\n${result.text}`;

// Second interaction
const followUpRes = await chain.call({
  question: "Was that nice?",
  chat_history: chatHistory,
});

In this code, we're updating chatHistory after each interaction by appending the user's message and the AI's response. This updated chatHistory is then passed to the next chain.call method.

Also, make sure that the BufferMemory instance is correctly configured. According to a similar issue in the langchainjs repository, you should specify an output key to tell the memory which one to use. This can be done by modifying the BufferMemory initialization as follows:

const memory = new BufferMemory({
  memoryKey: "chat_history",
  inputKey: "question",
  outputKey: "text",
});

I hope this helps! Let me know if you have any other questions.

Sources

• How can we add Memory to the dynamictool
• ConversationalRetrievalQAChain with FirestoreChatMessageHistory: problem with chat_history
• Keep the chat history context
• examples/src/agents/structured_chat_with_memory.ts
• examples/src/memory/xata-advanced.ts
• langchain/src/memory/buffer_memory.ts

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.