Building a Simple Chatbot with a Rules-Based Approach

Have you ever chatted with a customer service bot online or asked a virtual assistant a quick question? Those are chatbots! They’re computer programs designed to simulate human conversation. While some chatbots use advanced Artificial Intelligence (AI) to understand complex requests, many simple, yet effective, chatbots rely on a straightforward technique called a “rules-based approach.”

This blog post will guide you through building your very own simple chatbot using this rules-based method. It’s a fantastic starting point for beginners to understand the core concepts behind conversational AI without diving into complex machine learning.

What is a Chatbot?

Before we start building, let’s quickly define what a chatbot is.

• Chatbot: A chatbot is a computer program that simulates human conversation through text or voice interactions. Think of it as a digital assistant that can answer questions, perform tasks, or just chat!

Chatbots are everywhere, from helping you order food to providing customer support on websites. They come in various forms, but their goal is to make interactions with computers more natural and intuitive.

Why Choose a Rules-Based Approach?

There are different ways to build a chatbot, but for beginners, a rules-based approach is often the easiest to grasp. Here’s why:

• Simplicity: It’s straightforward to understand how it works. You define rules, and the bot follows them.
• Predictable: The bot will always respond in a predictable way based on the rules you set. This makes debugging (finding and fixing errors) much easier.
• No AI/Machine Learning Needed: You don’t need to understand complex AI algorithms or large datasets. This lowers the barrier to entry significantly.
• Great Learning Tool: It helps you understand fundamental concepts like pattern matching and input processing, which are crucial even for more advanced chatbots.

How Does a Rules-Based Chatbot Work?

A rules-based chatbot operates on a simple “if-then” logic. It works like this:

1. User Input: The user types a message or asks a question.
2. Pattern Matching: The chatbot looks for specific keywords or phrases (patterns) within the user’s message.
   • Pattern Matching: This means comparing the user’s input against a predefined list of words or sentence structures.
3. Rule Application: If a matching pattern is found, the chatbot applies the corresponding rule.
4. Predefined Response: Each rule has a predefined response associated with it. The chatbot then sends this response back to the user.
5. Fallback: If no matching pattern is found, the chatbot usually has a default or “fallback” response, like “I don’t understand.”

Let’s imagine you ask a simple bot, “What is your name?”
The bot has a rule:
* IF the user’s message contains “name” or “who are you”
* THEN respond with “I am a simple chatbot.”

When your message comes in, the bot quickly checks if it contains “name.” It does! So, it sends back the predefined response. Simple, right?

Building Our Simple Chatbot in Python

We’ll use Python for our chatbot because it’s a very beginner-friendly language known for its readability.

Step 1: Setting Up Our Rules

First, let’s define the rules our chatbot will follow. We’ll use a Python dictionary, where each “key” is a pattern (what we’re looking for in the user’s message) and the “value” is the corresponding response.

We’ll also introduce a simple way to do pattern matching using Regular Expressions (often shortened to “regex”). Don’t worry, we’ll keep it simple!

• Regular Expressions (Regex): These are special text strings used for describing a search pattern. They allow you to look for more than just exact words, like “hello” OR “hi” OR “hey.”

import re # We need the 're' module for regular expressions

rules = {
    r"hello|hi|hey": "Hello there! How can I assist you today?",
    r"how are you|how do you do": "I'm just a computer program, but I'm doing well! How about you?",
    r"your name|who are you": "I am a simple rules-based chatbot, but you can call me Botty!",
    r"weather": "I cannot provide real-time weather information. My apologies!",
    r"help": "I can answer simple questions based on predefined rules. Try asking about my name or how I am.",
    r"thank you|thanks": "You're welcome! Is there anything else I can help with?",
    r"bye|goodbye|see you": "Goodbye! Have a great day!",
    r".*": "I'm sorry, I don't quite understand. Could you rephrase or ask something else?" # Default fallback rule
}

In the rules dictionary:
* r"hello|hi|hey": The r before the string means it’s a “raw string,” which is good practice for regex. The | means “OR.” So, this pattern matches “hello” OR “hi” OR “hey.”
* .*: This is a special regex pattern that matches any character (.) zero or more times (*). We put this as our last rule, and it acts as a fallback response if no other rule matches.

Step 2: Cleaning User Input

User input can be messy. People might use different capitalization, punctuation, or extra spaces. To make our pattern matching more reliable, we should “clean” the input.

def clean_input(text):
    """
    Cleans the user's input by converting it to lowercase
    and removing most punctuation.
    """
    # Remove all non-alphanumeric characters (except spaces)
    # and convert to lowercase
    cleaned_text = re.sub(r'[^\w\s]', '', text.lower())
    return cleaned_text

• re.sub(r'[^\w\s]', '', text.lower()): This is a powerful regex function.
  • text.lower(): Converts the entire input to lowercase.
  • r'[^\w\s]': This is our pattern.
    • \w: Matches any word character (alphanumeric and underscore).
    • \s: Matches any whitespace character (spaces, tabs, newlines).
    • ^: When inside [], it negates the set. So [^\w\s] means “match anything that is NOT a word character AND NOT a whitespace character.”
  • '': Replaces the matched characters with an empty string, effectively removing them.

Step 3: Getting a Chatbot Response

Now, let’s create a function that takes the user’s cleaned input and finds the best response from our rules dictionary.

def get_chatbot_response(user_message):
    """
    Matches the cleaned user message against our rules and
    returns a corresponding response.
    """
    cleaned_message = clean_input(user_message)

    for pattern, response in rules.items():
        # re.search() looks for a pattern anywhere in the string
        if re.search(pattern, cleaned_message):
            return response

    # This line should ideally not be reached if the ".*" fallback rule is always present
    return "Oops! Something went wrong with my rules."

• rules.items(): This gives us both the pattern and the response for each rule.
• re.search(pattern, cleaned_message): This checks if the pattern exists anywhere within the cleaned_message. If it finds a match, it returns a match object; otherwise, it returns None. We treat a match object as True.

Step 4: Creating the Chatbot Loop

Finally, let’s put it all together into an interactive loop so you can chat with your bot!

print("Welcome to Simple Chatbot! Type 'quit' to exit.")

while True:
    user_input = input("You: ")

    if user_input.lower() == "quit":
        print("Chatbot: Goodbye! Thanks for chatting.")
        break

    response = get_chatbot_response(user_input)
    print(f"Chatbot: {response}")

Full Code Example

Here’s the complete code you can run:

import re

rules = {
    r"hello|hi|hey": "Hello there! How can I assist you today?",
    r"how are you|how do you do": "I'm just a computer program, but I'm doing well! How about you?",
    r"your name|who are you": "I am a simple rules-based chatbot, but you can call me Botty!",
    r"weather": "I cannot provide real-time weather information. My apologies!",
    r"help": "I can answer simple questions based on predefined rules. Try asking about my name or how I am.",
    r"thank you|thanks": "You're welcome! Is there anything else I can help with?",
    r"bye|goodbye|see you": "Goodbye! Have a great day!",
    r".*": "I'm sorry, I don't quite understand. Could you rephrase or ask something else?" # Default fallback rule
}

def clean_input(text):
    """
    Cleans the user's input by converting it to lowercase
    and removing most punctuation.
    """
    # Remove all non-alphanumeric characters (except spaces)
    # and convert to lowercase
    cleaned_text = re.sub(r'[^\w\s]', '', text.lower())
    return cleaned_text

def get_chatbot_response(user_message):
    """
    Matches the cleaned user message against our rules and
    returns a corresponding response.
    """
    cleaned_message = clean_input(user_message)

    for pattern, response in rules.items():
        # re.search() looks for a pattern anywhere in the string
        if re.search(pattern, cleaned_message):
            return response

    # This line should ideally not be reached if the ".*" fallback rule is always present
    return "Oops! Something went wrong with my rules."

print("Welcome to Simple Chatbot! Type 'quit' to exit.")

while True:
    user_input = input("You: ")

    if user_input.lower() == "quit":
        print("Chatbot: Goodbye! Thanks for chatting.")
        break

    response = get_chatbot_response(user_input)
    print(f"Chatbot: {response}")

Copy this code into a Python file (e.g., chatbot.py) and run it from your terminal using python chatbot.py. Try chatting with your new bot!

Enhancing Your Chatbot (Next Steps)

This simple bot is just the beginning! Here are some ideas to make it more advanced:

• More Complex Patterns: Use more sophisticated regular expressions to catch variations in user input (e.g., matching numbers, dates).
• Context/State Management: Our current bot doesn’t “remember” past conversations. You could add logic to keep track of the conversation’s context. For example, if a user asks “What is your name?” and then “How old are you?”, the bot could remember it’s talking about itself.
• Multiple Responses: Instead of a single response, have a list of possible responses for each rule, and the bot can pick one randomly for more variety.
• Integrating with APIs: This is where the “Web & APIs” category comes in!
  • API (Application Programming Interface): An API is like a menu that defines how different software programs can communicate with each other. If you want your chatbot to tell you the weather, you’d integrate it with a weather API.
  • For example, if the user asks “What’s the weather in London?”, your chatbot could:
    1. Identify “weather” and “London” as keywords.
    2. Make a request to an external weather API (like OpenWeatherMap) to get the current weather for London.
    3. Format the API’s response into a natural language sentence and tell it to the user.

Limitations of Rules-Based Chatbots

While easy to build, rules-based chatbots have limitations:

• Scalability: As you add more rules, managing them becomes complex. It’s hard to anticipate every possible way a user might phrase a question.
• Lack of Understanding: They don’t truly “understand” language; they just match patterns. If a user asks something slightly different from a predefined rule, the bot will fail.
• No Learning: They don’t learn from interactions. You have to manually update their rules for new knowledge.

For more complex, human-like interactions, chatbots typically use Natural Language Processing (NLP) and Machine Learning (ML) techniques, which allow them to understand the meaning behind sentences, not just keywords.

Conclusion

Congratulations! You’ve successfully built a simple rules-based chatbot. This foundational project gives you a great understanding of how conversational agents work at their most basic level. You’ve learned about pattern matching, cleaning input, and creating an interactive loop.

Remember, every complex system starts with simple building blocks. As you continue your journey in tech, you can expand on this basic concept to create more intelligent and helpful chatbots, perhaps by integrating them with APIs to access external information or even exploring the exciting world of AI and machine learning!