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

[Elindo586]

Conversation:

"Hi my name is 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: "I'm sorry, but I don't have that information." }
 ✓ Compiled in 132ms (146 modules)

Code using Next.js -- pages/api/usestore2.js :

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,
          // },
        }),
      }
    );
    let chatHistory = "";
    result = await chain.call({
      question: message,
      chat_history: chatHistory,
      // Add the new user message here
      // { role: 'user', content: message },
    });
    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 Jack,

The issue you're experiencing is due to the way the BufferMemory is being used in your code. The BufferMemory class in the langchainjs codebase is designed for storing and managing previous chat messages, not personal data like a user's name.

In your current implementation, the BufferMemory is initialized with the keys chat_history, question, and text. These keys are used to store the chat history, input questions, and output text respectively. If you want the AI to remember the user's name, you would need to modify the code to store this information and retrieve it when needed. This could be done by adding a new key-value pair to the memory buffer where the key is something like "user_name" and the value is the user's name.

However, please note that storing personal data like this may have privacy implications and should be done in accordance with relevant data protection laws and regulations.

Here's an example of how you might modify the BufferMemory initialization to store the user's name:

const memory = new BufferMemory({
    memoryKey: "chat_history",
    inputKey: "question",
    outputKey: "text",
    userName: "Jack" // Add this line
});

Then, in your chain.call method, you would need to add the userName to the input object:

result = await chain.call({
  question: message,
  chat_history: chatHistory,
  userName: "Jack" // Add this line
});

And finally, in your chain.call for the follow-up question, you would retrieve the user's name from the memory:

const followUpRes = await chain.call({
  question: `Was that nice, ${memory.userName}?`, // Use the user's name here
  chat_history: chatHistory,
});

Please note that this is a simplified example and you may need to adjust it to fit your specific use case. Also, remember that the BufferMemory is not designed to store personal data, so this solution may not be ideal for all situations.

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

Best,
Dosu

Sources

• ConversationalRetrievalQAChain with FirestoreChatMessageHistory: problem with chat_history
• Keep the chat history context
• Chat History not beeing retrieved / saved
• examples/src/chains/conversational_qa_built_in_memory.ts
• langchain/src/agents/toolkits/conversational_retrieval/openai_functions.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.