{"id":8888,"date":"2024-01-25T17:26:28","date_gmt":"2024-01-26T01:26:28","guid":{"rendered":"https:\/\/live-cometml.pantheonsite.io\/?p=8888"},"modified":"2025-04-24T17:03:26","modified_gmt":"2025-04-24T17:03:26","slug":"enhance-conversational-agents-with-langchain-memory","status":"publish","type":"post","link":"https:\/\/www.comet.com\/site\/blog\/enhance-conversational-agents-with-langchain-memory\/","title":{"rendered":"Enhance Conversational Agents with LangChain Memory"},"content":{"rendered":"\n
\n
LangChain Conversation Memory Types: Pros & Cons, and Code Examples<\/span><\/div>\n
\n
\n

When it comes to chatbots and conversational agents, the ability to retain and remember information is critical to creating fluid, human-like interactions. This article describes the concept of memory in LangChain and explores its importance, implementation, and various strategies for optimizing conversation flow.<\/p>\n

\ud83d\udca1I write about Machine Learning on Medium<\/a> || Github<\/a> || Kaggle<\/a> || Linkedin<\/a>. \ud83d\udd14 Follow \u201cNhi Yen\u201d for future updates!<\/p><\/blockquote>\n

\n<\/figure><\/div><\/div><\/section>\n\n\n\n
\"\"\/
Conversation Memory (Credit: Unsplash<\/a>)<\/figcaption><\/figure>\n\n\n\n

\ud83d\udc49 I previously shared relevant articles on creating a basic chatbot without using Conversation Memory. You might find it interesting.<\/em><\/p>\n\n\n\n

Why Memory Matters in Conversational Agents<\/h3>\n\n\n\n

When users interact with chatbots, they often expect a level of continuity and understanding similar to human conversations. This expectation includes the ability to refer to past information, which leads to the conversational agent\u2019s need for memory. Memory allows the system to remember previous interactions, process abbreviations, and perform co-reference resolution, ensuring consistent, context-aware conversations.<\/p>\n\n\n\n

The Memory Challenge in Large Language Models<\/h3>\n\n\n\n

Large language models like LangChain do not have their own memory. Unlike humans, who naturally retain information during conversations, these models operate on a rapid response mechanism. Attempts have been made to integrate memory into its Transformer model, but large-scale practical implementation remains a challenge.<\/p>\n\n\n\n

\n<\/figure>\n\n\n\n
\"Enhance
LangChain (Image Credit: ALEX XU on blog.bytebytego.com<\/a>)<\/figcaption><\/figure>\n\n\n\n

Memory Strategies in LangChain<\/h3>\n\n\n\n

Given a context that when a customer inquires about the customer service of a fashion store and expresses a problem with the jeans. This issue involves a stuck zipper and is similar to a hardware issue. I\u2019ll ask the conversational agent bot a list of questions for each LangChain memory type:<\/p>\n\n\n\n

1. Hey! I am Nhi.\n2. How are you today?\n3. I'm doing well, thank you. I need your assistance.\n4. I bought this pair of jeans, and there's a problem.\n5. When I tried them on, the zipper got stuck, and now I can't unzip it.\n6. It seems to be a problem with the zipper.<\/span><\/pre>\n\n\n\n
In this experiment, I\u2019ll use Comet LLM to record prompts, responses, and metadata for each memory type for performance optimization purposes. This allows me to track response duration, tokens, and cost for each interaction. View the full project HERE<\/strong><\/a>.<\/p>\n\n\n\n
Comet LLM provides additional features<\/a> such as UI visualization, detailed chain execution logs, automatic tracking with OpenAI chat model, and user feedback analysis.<\/p>\n\n\n\n
Find the complete code in this GitHub Repository<\/strong><\/a>.<\/p>\n\n\n\n
\n
\n
\n<\/div>\n
\n
\n
To start, bring in the common libraries needed for all 6 memory types. Make sure you\u2019ve installed the necessary Python packages in requirements.txt<\/em><\/strong> and have your OpenAI API and Comet API keys ready. (Reference: OpenAI Help Center\u200a\u2014\u200aWhere can I find my API key?<\/em><\/a>; CometLLM\u200a\u2014\u200aObtaining your API key<\/em><\/a>)<\/p>\n
import os\nimport dotenv\nimport comet_llm\nfrom langchain.callbacks import get_openai_callback\nimport time\ndotenv.load_dotenv()\n\nMY_OPENAI_KEY = os.getenv(\"YOUR_OPENAI_KEY\")\nMY_COMET_KEY = os.getenv(\"YOUR_COMET_KEY\")\n\n# Initialize a Comet project\ncomet_llm.init(project=\"YOUR COMET PROJECT NAME\",\n               api_key=MY_COMET_KEY)<\/span><\/pre>\n
1. Conversation Buffer Memory<\/h3>\n
The simplest form of memory involves the creation of a talk buffer. In this approach, the model keeps a record of ongoing conversations and accumulates each user-agent interaction into a message. While effective for limited interactions, scalability becomes an issue for long conversations.<\/p>\n
\ud83c\udfaf Implementation: Include the entire conversation in the prompt.<\/p>\n
\u2705 Pros: Simple and effective for short interactions.<\/p>\n
\u274c Cons: Limited by token span; impractical for lengthy conversations.<\/p>\n
from langchain.chains.conversation.memory import ConversationBufferMemory\nfrom langchain_openai import OpenAI\nfrom langchain.chains import ConversationChain\nfrom langchain.callbacks import get_openai_callback\n\nllm = OpenAI(openai_api_key=MY_OPENAI_KEY,\n             temperature=0,\n             max_tokens = 256)\n\nbuffer_memory = ConversationBufferMemory()\n\nconversation = ConversationChain(\n    llm=llm,\n    verbose=True,\n    memory=buffer_memory\n)<\/span><\/pre>\n
Interact with the conversational agent bot by inputting each prompt in conversation.predict()<\/code>. Example:<\/p>\n
conversation.predict(input=\"Hey! I am Nhi.\")<\/span><\/pre>\n
conversation.predict(input=\"How are you today?\")<\/span><\/pre>\n
conversation.predict(input=\"I'm doing well, thank you. I need your assistant.\")<\/span><\/pre>\n
Output after the 3rd prompt:<\/p>\n
> Entering new ConversationChain chain...\nPrompt after formatting:\nThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n\nCurrent conversation:\nHuman: Hey! I am Nhi.\nAI:  Hi Nhi! My name is AI. It's nice to meet you. What can I do for you today?\nHuman: How are you today?\nAI:  I'm doing great, thanks for asking! I'm feeling very excited about the new projects I'm working on. How about you?\nHuman: I'm doing well, thank you. I need your assistant.\nAI:\n\n> Finished chain.\n' Sure thing! What kind of assistance do you need?'<\/span><\/pre>\n
ConversationBufferMemory<\/code> allows conversations to grow with each turn and allows users to see the entire conversation history at any time. This approach allows ongoing interactions to be monitored and maintained, providing a simple but powerful form of memory for language models, especially in scenarios where the number of interactions with the system is limited.<\/p>\n
print(conversation.memory.buffer)<\/span><\/pre>\n
Output:<\/p>\n
Human: Hey! I am Nhi.\nAI:  Hi Nhi! My name is AI. It's nice to meet you. What can I do for you today?\nHuman: How are you today?\nAI:  I'm doing great, thanks for asking! I'm feeling very excited about the new projects I'm working on. How about you?\nHuman: I'm doing well, thank you. I need your assistant.\nAI:  Sure thing! What kind of assistance do you need?<\/span><\/pre>\n
Use Comet LLM to complete the code and record relevant information for analysis purposes.<\/p>\n
def conversation_memory_buffer(prompt):\n    with get_openai_callback() as cb:\n        start_time = time.time()\n        response = conversation.predict(input=prompt)\n        end_time = time.time()\n        print(f\"Response: {response}\")\n        print(f\"History: {conversation.memory.buffer}\")\n\n        # Log to comet_llm\n        comet_llm.log_prompt(\n            prompt=prompt,\n            output=response,\n            duration= end_time - start_time,\n            prompt_template = conversation.prompt.template,\n            metadata={\n            \"memory_type\": \"conversation_buffer_memory\",\n            \"history\": conversation.memory.buffer,\n            \"total_tokens\": cb.total_tokens,\n            \"prompt_tokens\": cb.prompt_tokens,\n            \"completion_tokens\": cb.completion_tokens,\n            \"total_cost_usd\": cb.total_cost\n            },\n        )<\/span><\/pre>\n
Call the function conversation_memory_buffer()<\/code>:<\/p>\n
Example:\nconversation_memory_buffer(\"Hey! I am Nhi.\")\nconversation_memory_buffer(\"How are you today?\")\nconversation_memory_buffer(\"I'm doing well, thank you. I need your assistant.\")<\/span><\/pre>\n
How the data is logged in Comet LLM:<\/p>\n
\n<\/figure><\/div><\/div><\/section>\n\n\n\n
\"Enhance
Input\/output are logged in Comet LLM (Image by the\u00a0Author)<\/figcaption><\/figure>\n\n\n\n
<\/figcaption>\n\n\n\n
\n<\/figure>\n\n\n\n
\"Enhance
Logging the metadata in Comet LLM (Image by the Author)<\/figcaption><\/figure>\n\n\n\n
 \n<\/p>\n\n\n\n
2. Conversation Summary Memory<\/h3>\n\n\n\n
To overcome the scalability challenge, Conversation Summary Memory provides a solution. Rather than accumulating each interaction, the model generates a condensed summary of the essence of the conversation. This reduces the number of tokens and increases the sustainability of long-term interactions.<\/p>\n\n\n\n
\ud83c\udfaf Implementation: Summarize the conversation to save tokens.<\/p>\n\n\n\n
\u2705 Pros: Efficient token usage over time.<\/p>\n\n\n\n
\u274c Cons: May lose fine-grained details; suitable for concise interactions.<\/p>\n\n\n\n
from langchain.chains.conversation.memory import ConversationSummaryMemory\nfrom langchain import OpenAI\nfrom langchain.chains import ConversationChain\nfrom langchain.callbacks import get_openai_callback\n\n# Create an instance of the OpenAI class with specified parameters\nllm = OpenAI(openai_api_key=MY_OPENAI_KEY,\n            temperature=0,\n            max_tokens = 256)\n\n# Create an instance of the ConversationSummaryMemory class\nsummary_memory = ConversationSummaryMemory(llm=OpenAI(openai_api_key=MY_OPENAI_KEY))\n\n# Create an instance of the ConversationChain class, combining OpenAI, verbose mode, and memory\nconversation = ConversationChain(\n    llm=llm,\n    verbose=True,\n    memory=summary_memory\n)<\/span><\/pre>\n\n\n\n
Similar to ConversationBufferMemory, we\u2019ll also interact with the conversational agent bot by inputting each prompt in conversation.predict()<\/code>. Example:<\/p>\n\n\n\n
conversation.predict(input=\"Hey! I am Nhi.\")<\/span><\/pre>\n\n\n\n
conversation.predict(input=\"How are you today?\")<\/span><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
> Entering new ConversationChain chain...\nPrompt after formatting:\nThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n\nCurrent conversation:\n\nNhi introduces themselves to the AI and the AI responds with a greeting, revealing its name to be AI. The AI offers to assist Nhi with any tasks and asks how it can help them today. The human then asks how the AI is doing, to which it responds that it is doing great and asks how it can be of assistance.\nHuman: I'm doing well, thank you. I need your assistant.\nAI:\n\n> Finished chain.\n' Absolutely! How can I help you today?'<\/span><\/pre>\n\n\n\n
The ConversationSummaryMemory<\/em><\/strong> generates the conversation summary over multiple interactions.<\/p>\n\n\n\n
Current conversation:\nNhi introduces themselves to the AI and the AI responds with a greeting, revealing its name to be AI. The AI offers to assist Nhi with any tasks and asks how it can help them today. The human then asks how the AI is doing, to which it responds that it is doing great and asks how it can be of assistance.<\/span><\/pre>\n\n\n\n
The summaries capture key points of the conversation, including introductions, queries, and responses. As the conversation progresses, the model generates summarized versions, emphasizing that it tends to use fewer tokens over time. The summary\u2019s ability is to retain essential information, making it useful for reviewing the conversation as a whole.<\/p>\n\n\n\n
Additionally, we can access and print out the conversation summary.<\/p>\n\n\n\n
print(conversation.memory.buffer)<\/span><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Nhi introduces themselves to the AI and the AI responds with a greeting, revealing its name to be AI. The AI offers to assist Nhi with any tasks and asks how it can help them today. The human asks how the AI is doing, to which it responds that it is doing great and asks how it can be of assistance. The human informs the AI that they need its assistance and the AI eagerly offers to help.<\/span><\/pre>\n\n\n\n
Use Comet LLM to log important information for analysis purposes in your code.<\/p>\n\n\n\n
def conversation_summary_memory(prompt):\n    with get_openai_callback() as cb:\n        start_time = time.time()\n        response = conversation.predict(input=prompt)\n        end_time = time.time()\n        print(f\"Response: {response}\")\n        print(f\"History: {conversation.memory.buffer}\")\n\n        # Log to comet_llm\n        comet_llm.log_prompt(\n            prompt=prompt,\n            output=response,\n            duration= end_time - start_time,\n            prompt_template = conversation.prompt.template,\n            metadata={\n            \"memory_type\": \"conversation_summary_memory\",\n            \"history\": conversation.memory.buffer,\n            \"total_tokens\": cb.total_tokens,\n            \"prompt_tokens\": cb.prompt_tokens,\n            \"completion_tokens\": cb.completion_tokens,\n            \"total_cost_usd\": cb.total_cost\n            },\n        )<\/span><\/pre>\n\n\n\n
Call the function conversation_memory_buffer()<\/code>:<\/p>\n\n\n\n
Example:\nconversation_summary_memory(\"Hey! I am Nhi.\")\nconversation_summary_memory(\"How are you today?\")\nconversation_summary_memory(\"I'm doing well, thank you. I need your assistant.\")<\/span><\/pre>\n\n\n\n
3. Conversation Buffer Window Memory<\/h3>\n\n\n\n
Conversation Buffer Window Memory is an alternative version of the conversation buffer approach, which involves setting a limit on the number of interactions considered within a memory buffer. This balances memory depth and token efficiency, and provides flexibility to adapt to conversation windows.<\/p>\n\n\n\n
\ud83c\udfaf Implementation: Retain the last N interactions.<\/p>\n\n\n\n
\u2705 Pros: Balances memory and token constraints.<\/p>\n\n\n\n
\u274c Cons: Potential loss of early conversation context.<\/p>\n\n\n\n
from langchain.chains.conversation.memory import ConversationBufferWindowMemory\nfrom langchain import OpenAI\nfrom langchain.chains import ConversationChain\nfrom langchain.callbacks import get_openai_callback\n\n# Create an instance of the OpenAI class with specified parameters\nllm = OpenAI(openai_api_key=MY_OPENAI_KEY,\n            model_name='text-davinci-003',\n            temperature=0,\n            max_tokens = 256)\n\n# Create an instance of the ConversationBufferWindowMemory class\n# We set a low k=2, to only keep the last 2 interactions in memory\nwindow_memory = ConversationBufferWindowMemory(k=2)\n\n# Create an instance of the ConversationChain class, combining OpenAI, verbose mode, and memory\nconversation = ConversationChain(\n    llm=llm,\n    verbose=True,\n    memory=window_memory\n)<\/span><\/pre>\n\n\n\n
Note that in this demo we will set a low value k=2<\/code> , but you can adjust it depending on the memory depth you need. Four prompts are introduced into the model in the following order:<\/p>\n\n\n\n
conversation.predict(input=\"Hey! I am Nhi.\")<\/span><\/pre>\n\n\n\n
conversation.predict(input=\"I'm doing well, thank you. I need your assistant.\")<\/span><\/pre>\n\n\n\n
conversation.predict(input=\"I bought this pair of jeans, and there's a problem.\")<\/span><\/pre>\n\n\n\n
conversation.predict(input=\"When I tried them on, the zipper got stuck, and now I can't unzip it.\")<\/span><\/pre>\n\n\n\n
In the demo, the prompt contains an ongoing conversation, and the model tracks a set number of recent interactions. However, only the last 02 interactions are considered, so the previous interactions are not preserved.<\/p>\n\n\n\n
\n<\/figure>\n\n\n\n
\"\"\/
Our output<\/figcaption><\/figure>\n\n\n\n
Memory depth can be adjusted based on factors such as token usage and cost considerations. We compare our approach with previous approaches and emphasize selectively preserving recent interactions.<\/p>\n\n\n\n
print(conversation.memory.buffer)<\/span><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Human: I bought this pair of jeans, and there's a problem.\nAI:  Oh no! What kind of problem are you having with the jeans?\nHuman: When I tried them on, the zipper got stuck, and now I can't unzip it.\nAI:  That sounds like a tricky problem. Have you tried lubricating the zipper with a bit of oil or WD-40? That might help loosen it up.<\/span><\/pre>\n\n\n\n
Use Comet LLM to log important information for analysis in your code:<\/p>\n\n\n\n
def conversation_buffer_window_memory(prompt):\n    with get_openai_callback() as cb:\n        start_time = time.time()\n        response = conversation.predict(input=prompt)\n        end_time = time.time()\n        print(f\"Response: {response}\")\n        print(f\"History: {conversation.memory.buffer}\")\n\n        # Log to comet_llm\n        comet_llm.log_prompt(\n            prompt=prompt,\n            output=response,\n            duration= end_time - start_time,\n            prompt_template = conversation.prompt.template,\n            metadata={\n            \"memory_type\": \"conversation_buffer_window_memory\",\n            \"history\": conversation.memory.buffer,\n            \"total_tokens\": cb.total_tokens,\n            \"prompt_tokens\": cb.prompt_tokens,\n            \"completion_tokens\": cb.completion_tokens,\n            \"total_cost_usd\": cb.total_cost\n            },\n        )<\/span><\/pre>\n\n\n\n
Call the function conversation_buffer_window_memory()<\/code>:<\/p>\n\n\n\n
Example:\nconversation_buffer_window_memory(\"Hey! I am Nhi.\")\nconversation_buffer_window_memory(\"How are you today?\")\nconversation_buffer_window_memory(\"I'm doing well, thank you. I need your assistant.\")<\/span><\/pre>\n\n\n\n
4. Conversation Summary Buffer Memory: A Combination of Conversation Summary and Buffer Memory<\/h3>\n\n\n\n
Conversation Summary Buffer Memory keeps a buffer of recent interactions in memory, but compiles them into a digest and uses both, rather than just removing old interactions completely.<\/p>\n\n\n\n
\ud83c\udfaf Implementation: Merge summary and buffer for optimal memory usage.<\/p>\n\n\n\n
\u2705 Pros: Provides a comprehensive view of recent and summarized interactions.<\/p>\n\n\n\n
\u274c Cons: Requires careful tuning for specific use cases.<\/p>\n\n\n\n
from langchain.chains.conversation.memory import ConversationSummaryBufferMemory\nfrom langchain import OpenAI\nfrom langchain.chains import ConversationChain\nfrom langchain.callbacks import get_openai_callback\n\n\n# Create an instance of the OpenAI class with specified parameters\nllm = OpenAI(openai_api_key=MY_OPENAI_KEY,\n            temperature=0,\n            max_tokens = 512)\n\n# Create an instance of the ConversationSummaryBufferMemory class\n# Setting k=2: Retains only the last 2 interactions in memory.\n# max_token_limit=40: Requires the installation of transformers.\nsummary_buffer_memory = ConversationSummaryBufferMemory(llm=OpenAI(openai_api_key=MY_OPENAI_KEY), max_token_limit=40)\n\n# Create an instance of the ConversationChain class, combining OpenAI, verbose mode, and memory\nconversation = ConversationChain(\n    llm=llm,\n    memory=summary_buffer_memory,\n    verbose=True\n)<\/span><\/pre>\n\n\n\n
Feed the model with 4 prompts in an order:<\/p>\n\n\n\n
conversation.predict(input=\"Hey! I am Nhi.\")<\/span><\/pre>\n\n\n\n
conversation.predict(input=\"I bought this pair of jeans, and there's a problem.\")<\/span><\/pre>\n\n\n\n
conversation.predict(input=\"When I tried them on, the zipper got stuck, and now I can't unzip it.\")<\/span><\/pre>\n\n\n\n
conversation.predict(input=\"It seems to be a problem with the zipper.\")<\/span><\/pre>\n\n\n\n
The model retains the last 2 interactions and summarize the older ones as below:<\/p>\n\n\n\n
> Entering new ConversationChain chain...\nPrompt after formatting:\nThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n\nCurrent conversation:\nSystem:\nNhi introduces herself to the AI, and the AI responds by introducing itself and expressing pleasure in meeting Nhi. Nhi mentions a problem with a pair of jeans she bought, and the AI asks for more details. Nhi explains that the zipper got stuck and now she can't unzip it.\nAI:  That sounds like a tricky situation. Have you tried lubricating the zipper with a bit of oil or soap? That might help it move more smoothly.\nHuman: It seems to be a problem with the zipper.\nAI:\n\n> Finished chain.\n' It sounds like the zipper is stuck. Have you tried lubricating it with a bit of oil or soap? That might help it move more smoothly.'<\/span><\/pre>\n\n\n\n
Print out the result:<\/p>\n\n\n\n
print(conversation.memory.moving_summary_buffer)<\/span><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Nhi introduces themselves to the AI and the AI responds by introducing itself and offering assistance. Nhi explains a problem with a pair of jeans they bought, stating that the zipper is stuck and they can't unzip it. The AI suggests lubricating the zipper with oil or soap to help it move more smoothly or replacing it if that doesn't work.<\/span><\/pre>\n\n\n\n
Use Comet LLM in your code to log important information for analysis:<\/p>\n\n\n\n
def conversation_summary_buffer_memory(prompt):\n    with get_openai_callback() as cb:\n        start_time = time.time()\n        response = conversation.predict(input=prompt)\n        end_time = time.time()\n        print(f\"Response: {response}\")\n        print(f\"History: {conversation.memory.moving_summary_buffer}\")\n\n        # Log to comet_llm\n        comet_llm.log_prompt(\n            prompt=prompt,\n            output=response,\n            duration= end_time - start_time,\n            prompt_template = conversation.prompt.template,\n            metadata={\n            \"memory_type\": \"conversation_summary_buffer_memory\",\n            \"history\": conversation.memory.moving_summary_buffer,\n            \"total_tokens\": cb.total_tokens,\n            \"prompt_tokens\": cb.prompt_tokens,\n            \"completion_tokens\": cb.completion_tokens,\n            \"total_cost_usd\": cb.total_cost\n            },\n        )<\/span><\/pre>\n\n\n\n
Call the function conversation_summary_buffer_memory()<\/code>:<\/p>\n\n\n\n
Example:\nconversation_summary_buffer_memory(\"Hey! I am Nhi.\")\nconversation_summary_buffer_memory(\"I bought this pair of jeans, and there's a problem.\")\nconversation_summary_buffer_memory(\"When I tried them on, the zipper got stuck, and now I can't unzip it.\")\nconversation_summary_buffer_memory(\"It seems to be a problem with the zipper.\")<\/span><\/pre>\n\n\n\n
5. Conversation Knowledge Graph Memory<\/h3>\n\n\n\n
LangChain goes beyond just conversation tracking and introduces knowledge graph memory. It builds a mini knowledge graph based on related information, creating nodes and connections to represent key entities. This method improves the model\u2019s ability to understand and respond to situations.<\/p>\n\n\n\n
\ud83c\udfaf Implementation: Extract relevant information and construct a knowledge graph.<\/p>\n\n\n\n
\u2705 Pros: Enables structured information extraction.<\/p>\n\n\n\n
\u274c Cons: May require additional processing for complex scenarios.<\/p>\n\n\n\n
\n<\/figure>\n\n\n\n
\"Enhance
Knowledge Graph Memory in LLM (Image by the\u00a0Author)<\/figcaption><\/figure>\n\n\n\n
<\/figcaption>\n\n\n\n
Python Code example:<\/p>\n\n\n\n
from langchain.chains.conversation.memory import ConversationKGMemory\nfrom langchain import OpenAI\nfrom langchain.chains import ConversationChain\nfrom langchain.prompts.prompt import PromptTemplate\nfrom langchain.callbacks import get_openai_callback\n\n# Create an instance of the OpenAI class with specified parameters\nllm = OpenAI(openai_api_key=MY_OPENAI_KEY,\n            temperature=0,\n            max_tokens = 256)\n\n# Define a template for conversation prompts\ntemplate = \"\"\"\nThis is a friendly chat between a human and an AI. The AI shares details from its context. \\n\nIf it doesn't know the answer, it honestly admits it. The AI sticks to information in the 'Relevant Information' section and doesn't make things up. \\n\\n\n\nRelevant Information: \\n\n\n{history}\n\nConversation: \\n\nHuman: {input} \\n\nAI:\"\"\"\n\n# Create an instance of the PromptTemplate class with specified input variables and template\nprompt = PromptTemplate(input_variables=[\"history\", \"input\"], template=template)\n\n# Create an instance of the ConversationKGMemory class with the OpenAI instance\nkg_memory = ConversationKGMemory(llm=llm)\n\n# Create an instance of the ConversationChain class, combining OpenAI, verbose mode, prompt, and memory\nconversation = ConversationChain(\n    llm=llm,\n    verbose=True,\n    prompt=prompt,\n    memory=kg_memory\n)<\/span><\/pre>\n\n\n\n
def conversation_kg_memory(prompt):\n    with get_openai_callback() as cb:\n        start_time = time.time()\n        response = conversation.predict(input=prompt)\n        end_time = time.time()\n        print(f\"Response: {response}\")\n        print(f\"History: {str(conversation.memory.kg.get_triples())}\")\n\n        # Log to comet_llm\n        comet_llm.log_prompt(\n            prompt=prompt,\n            output=response,\n            duration= end_time - start_time,\n            prompt_template = conversation.prompt.template,\n            metadata={\n            \"memory_type\": \"conversation_kg_memory\",\n            \"history\": str(conversation.memory.kg.get_triples()),\n            \"total_tokens\": cb.total_tokens,\n            \"prompt_tokens\": cb.prompt_tokens,\n            \"completion_tokens\": cb.completion_tokens,\n            \"total_cost_usd\": cb.total_cost\n            },\n        )<\/span><\/pre>\n\n\n\n
6. Entity Memory<\/h3>\n\n\n\n
Similar to Knowledge Graph memory, entity memory extracts specific entities from the conversation, such as names, objects, or locations. This focused approach aids in understanding and responding to user queries with greater precision.<\/p>\n\n\n\n
\ud83c\udfaf Implementation: Identify and store specific entities from the conversation.<\/p>\n\n\n\n
\u2705 Pros: Facilitates extraction of key information for decision-making.<\/p>\n\n\n\n
\u274c Cons: Sensitivity to entity recognition accuracy.<\/p>\n\n\n\n
from langchain import OpenAI, ConversationChain\nfrom langchain.chains.conversation.memory import ConversationEntityMemory\nfrom langchain.chains.conversation.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE\nfrom pydantic import BaseModel\nfrom typing import List, Dict, Any\nfrom langchain.callbacks import get_openai_callback\n\n# Print the template used for conversation prompts\nENTITY_MEMORY_CONVERSATION_TEMPLATE.template\nprint(ENTITY_MEMORY_CONVERSATION_TEMPLATE.template)\n\n# Create an instance of the OpenAI class with specified parameters\nllm = OpenAI(openai_api_key=MY_OPENAI_KEY,\n            temperature=0,\n            max_tokens = 256)\n\n# Create an instance of the ConversationEntityMemory class with the OpenAI instance\nentity_memory = ConversationEntityMemory(llm=llm)\n\n# Create an instance of the ConversationChain class, combining OpenAI, verbose mode, prompt, and memory\nconversation = ConversationChain(\n    llm=llm,\n    verbose=True,\n    prompt=ENTITY_MEMORY_CONVERSATION_TEMPLATE,\n    memory=entity_memory\n)<\/span><\/pre>\n\n\n\n
Create a function to get the response and log important metadata using CometLLM:<\/p>\n\n\n\n
def conversation_entity_memory(prompt):\n    with get_openai_callback() as cb:\n        start_time = time.time()\n        response = conversation.predict(input=prompt)\n        end_time = time.time()\n        print(f\"Response: {response}\")\n        print(f\"History: {conversation.memory.entity_store.store}\")\n\n        # Log to comet_llm\n        comet_llm.log_prompt(\n            prompt=prompt,\n            output=response,\n            duration= end_time - start_time,\n            prompt_template = conversation.prompt.template,\n            metadata={\n            \"memory_type\": \"conversation_entity_memory\",\n            \"entity_cache\": conversation.memory.entity_cache,\n            \"history\": conversation.memory.entity_store.store,\n            \"total_tokens\": cb.total_tokens,\n            \"prompt_tokens\": cb.prompt_tokens,\n            \"completion_tokens\": cb.completion_tokens,\n            \"total_cost_usd\": cb.total_cost\n            },\n        )<\/span><\/pre>\n\n\n\n
Call the function:<\/p>\n\n\n\n
conversation_entity_memory(\"Hi, this is Nhi. I bought this pair of jeans, and there's a problem. When I tried them on, the zipper got stuck, and now I can't unzip it.\")<\/span><\/pre>\n\n\n\n
The function returns the history, the matching response using Entity memory, and also logs metadata in Comet LLM as shown below.<\/p>\n\n\n\n
\n<\/figure>\n\n\n\n
\"\"\/
Response (Image by the\u00a0Author)<\/figcaption><\/figure>\n\n\n\n
<\/figcaption>\n\n\n\n
\n<\/figure>\n\n\n\n
\"Enhance
Input\/Output logged in Comet\u00a0LLM<\/figcaption><\/figure>\n\n\n\n
<\/figcaption>\n\n\n\n
\n<\/figure>\n\n\n\n
\"Enhance
Metadata logged in Comet LLM<\/figcaption><\/figure>\n\n\n\n
 \n<\/p>\n\n\n\n
Reference<\/strong><\/h3>\n\n\n\n