Deepen the Wisdom: Adding a Brain to Chanakya Neeti Chatbot with Custom Memory

5 min readFeb 25, 2024

Remember the wise companion we crafted in the previous article? Our Chanakya Neeti chatbot dispenses knowledge based on ancient wisdom. But imagine it becoming even more insightful, remembering past interactions and drawing upon them for personalized responses. This is the magic of adding memory to your chatbot, think of it as giving your chatbot a brain that grows smarter with every interaction. Let’s explore this exciting frontier together!

Why Memory Matters

Imagine a conversation where your chatbot recalls your favourite quotes, adapts responses based on previous questions, and even evolves based on your interactions. That’s the power of memory! It fosters a sense of continuity, engagement, and intelligence, making the chatbot feel more like a wise companion.

Why Understanding the Wheel Matters

In the world of coding, a smart saying exists: don’t reinvent the wheel. It means using existing solutions instead of building them from scratch, saving time and effort. This applies even when adding memory to your Chanakya Neeti chatbot.

Libraries like LangChain offer pre-built memory features, but building your own has a benefit: understanding how it works. Imagine peeking inside a complex machine, and seeing how its parts fit together. You’ll learn the secrets of memory systems from the inside out!

Get ready to dive into the next chapter, where we’ll build our custom memory system step-by-step, unlocking the secrets through hands-on practice!

Building Your Memory Bank: Data Structures and Logic

We’ll use Python’s building blocks to create this memory system from scratch.

Choosing the Right Data Structure:

We have two main options:

Dictionaries: Picture a dictionary as a phone book, but instead of names and numbers, it stores user questions (keys) and chatbot responses (values). Each interaction adds a new entry to this book. For example,

memory = {
    "What is your favorite quote?": "Knowledge is the eye of reason.",
    "Can you tell me a story?": "Once upon a time...",
}

Lists: Think of a list like a shopping list, but instead of groceries, it stores complete interactions (user questions and responses) in chronological order.

memory = [
    ["What is your name?", "My name is Gautam."],
    ["What is your purpose?", "Technical writing"],
]

Which option is better? It depends! Dictionaries make finding specific memories faster, like looking up a name in a phone book. Lists, on the other hand, remember things in the order they happened, like your shopping list. Choose the one that best fits your chatbot’s needs and the kind of memories you want to store.

Laying the Foundation:

Let’s pick a dictionary and write code to handle the core tasks,

1. Memory Structure with Timestamps

from datetime import datetime
from textblob import TextBlob
MAX_MEMORY_SIZE = 10
memory = {}

def store_memory(user_input, response):
    if user_input in memory:
        memory[user_input] = update_existing_memory(user_input, response)
    else:
        memory[user_input] = {"response": response, "timestamp": datetime.now()}


def update_existing_memory(user_input, response):
    existing_memory = memory[user_input]
    if context_matches(existing_memory["response"], response):
        existing_memory["timestamp"] = datetime.now()
        existing_memory["response"] = merge_responses(existing_memory["response"], response)
    else:
        memory[user_input + str(datetime.now())] = response
    return existing_memory["response"]

This code defines functions to store and update memories, including timestamps for time-sensitive responses or analyzing interaction trends. The update_existing_memory function handles duplicates based on your chosen strategy.

2. Context-Aware Memory Management:

Following enhanced memory management removes less valuable entries when needed. The context_matches the function uses keywords and sentiment analysis to determine if responses are similar, allowing for nuanced merging in the merge_responses function.

def forget_memory():
    """
    Removes least valuable entries from memory based on your chosen strategy.
    """
    # Implement strategy for removing entries:
    # for example- Least Recently Used (LRU) to Remove oldest entries.

def context_matches(response1, response2):
    """
    Analyzes the context of two responses to determine if they match.
    Use keywords, sentiment, or any relevant factors for more nuanced comparisons.
    """
    keywords_response1 = set(response1.split())
    keywords_response2 = set(response2.split())
    keyword_overlap = keywords_response1.intersection(keywords_response2)
    sentiment_response1 = TextBlob(response1).sentiment
    sentiment_response2 = TextBlob(response2).sentiment
    sentiment_similarity = abs(sentiment_response1.polarity - sentiment_response2.polarity)

    return len(keyword_overlap) > 0 and sentiment_similarity < 0.2

def merge_responses(response1, response2):
    """
    Merges similar responses to enrich the memory and preserve valuable information.
    Customize this to merge responses in a way that benefits your chatbot.
    """
    return response1 + " " + response2

3. Leveraging Your Chatbot Brain:

While this foundation provides a robust memory system, it’s only the first step. Now, let’s integrate it with your core chatbot logic,

NLP: Remember the power of NLP discussed in the previous article? Utilize it to understand user intent and extract key information from their input. This allows your chatbot to respond accurately and contextually.

Memory-Powered Responses: Don’t let stored memories gather dust! Access and leverage them in your responses to make them more informed, relevant, and engaging. Remember the user’s past questions, their sentiment, and the context of previous interactions.

This foundation is just the beginning. Consider adding features like sentiment analysis, entity recognition, and personalized recommendations to further enhance your chatbot’s intelligence.

With each step, you’ll refine your chatbot’s memory and communication abilities, making it an invaluable companion for your users.

Conclusion: From Data to Insightful Conversations

Remember the golden rule: “Don’t reinvent the wheel.” While pre-built libraries like LangChain offer memory solutions, building your offers deeper understanding and customization. By choosing dictionaries as our tool, we’ve laid a robust foundation for your Chanakya Neeti chatbot’s memory system.

This foundation goes beyond simple storage. We’ve incorporated timestamps for time-sensitive responses, context-aware memory management to avoid clutter and even sentiment analysis for nuanced understanding. While the provided code snippets serve as a starting point, remember to customize them based on your specific needs and desired functionalities.

But the journey doesn’t end here. This is just the first chapter in the story of your chatbot’s memory. As you venture further, consider incorporating advanced features like sentiment analysis, entity recognition, and personalized recommendations. With each step, your chatbot will become more intelligent, engaging, and truly valuable to your users.

So, unleash your creativity, explore the possibilities, and watch your Chanakya Neeti chatbot transform from a data store into a wise and insightful conversational companion!

References

Data Structures and Algorithms: Skiena, S. (2009). The Algorithm Design Manual. Springer. Retrieved from https://www.algorist.com/
Chatbot Design Best Practices: McTear, M. (2017). The Conversational Interface: Talking to Smart Devices. Springer. Retrieved from https://dl.acm.org/doi/10.5555/2965050

Deepen the Wisdom: Adding a Brain to Chanakya Neeti Chatbot with Custom Memory

References

Written by Gautam V.