A chatbot that answers five questions well beats one that answers fifty badly. Start with five. By the end of this guide you will have a Python program that holds a short conversation in your terminal, works out what someone is asking, and hands back a sensible reply. No training data required, no cloud account, no bills. Just Python, a text editor, and an hour of focused work.
Set Up Python and a Project Folder
Everything here runs on a standard Python 3 install. If Python is already on your machine, skip to step three.
- Install Python 3. Get the official installer from python.org. On Windows, tick the box that adds Python to your system path during setup.
- Check it works. Open a terminal and run python --version (or python3 --version on macOS and Linux). You want a 3.x number back, not an error.
- Create a folder. Call it first-chatbot and open it in your editor. VS Code and Thonny are both friendly to beginners.
- Make a virtual environment. Run python -m venv venv, then activate it. This keeps your chatbot's packages separate from everything else on your computer.
- Add a file. Create bot.py. That is where the code goes.
Only install packages when you actually need them. A rule-based bot can run on the standard library alone, which means fewer things to break before you have written a single reply.
Sketch the Bot Before You Write Code
Pick something narrow: a coffee shop bot, a study-schedule bot, a bot that answers questions about your club's opening times. Narrow is a feature, not a limitation.
Then write down ten messages a real person might send, in their own words. Not the polite version. The real one: "u open tmrw?", "how much for a large one", "hi". Group those messages into intents. For a small shop bot you might end up with greeting, hours, prices, location, talk-to-a-person, and unknown. Five or six intents is plenty for version one.
That sketch is your design document. Every line of code after this exists to sort a message into one of those buckets and choose a reply.
Build the Rule Engine
A dictionary of intents mapped to keywords, plus a function that picks the first match, gets you a working classifier in about a dozen lines.
import random
rules = {
"greeting": ["hello", "hi", "hey"],
"hours": ["open", "hours", "closing"],
"price": ["price", "cost", "how much"],
}
def classify(text):
text = text.lower()
for intent, keywords in rules.items():
if any(word in text for word in keywords):
return intent
return "unknown"
Now write a second dictionary, responses, keyed by the same intent names. Each value is a list of two or three phrasing options, and random.choice() picks one. Repeat the same reply word for word and the bot feels dead by the fourth message.
The last piece is the loop: ask for input, pass it to classify(), print the chosen reply, and break out when the user types "quit". Roughly six lines, and it is the only part of the program that talks to a human.
A bot that admits it does not know is easier to trust than one that guesses. Give the unknown case a real reply, not silence.
Make the Matching Smarter
The substring check above has one embarrassing flaw. The letters "hi" sit inside "this", "which", and "architecture". Ask "which days are you open?" and your greeting rule fires first.
Two fixes. Use word boundaries from the re module: re.search(r"\bhi\b", text). Or split the message into tokens first and compare whole words. Either one removes a whole category of silly answers.
When your keyword lists grow past a couple of dozen entries, a library earns its place:
- NLTK is the classic teaching toolkit. It ships a small chat module (nltk.chat.util) where you define pattern and response pairs, and it handles simple reflection, so "I am tired" can come back as a reply about you being tired.
- spaCy gives you tokenisation, lemmatisation and phrase matching. Lemmatisation means "opening", "opens" and "opened" all collapse to "open", so one keyword covers more phrasings than it should reasonably be allowed to.
Install them with pip install nltk or pip install spacy, and note that spaCy's English model needs a separate download command before it will load. Both are heavier than the standard library, so reach for them when your keyword lists start repeating themselves, not on day one.
Test It Like a Skeptic
Before you polish the wording of replies, try to break your own bot. Put the ten messages from your sketch into a list and loop over them, printing each one next to the intent the classifier chose. You will see the misfires immediately.
- Send an empty line. Does anything crash?
- Send "HELLO". The .lower() call should handle it, but confirm rather than assume.
- Send two intents at once: "what time do you open and how much is a large latte?" The loop returns the first match, so order your rules deliberately and decide which intent wins.
- Send something rude about your shop. A calm default reply lands better than a crash or a blank line.
- Log every "unknown" reply to a file. Those lines are your next five rules, written by the only people whose opinion matters.
Put It Somewhere People Can Reach It
The terminal loop is fine while you are building. When you are ready to move, the detail that matters is this: classify() takes a string and returns a reply string, and nothing else. Keep that shape and you can call it from almost anywhere. A small Flask or FastAPI route puts it on a web page.
Photo: Pexels / Pixabay
