How to Make a Chatbot in Python Step by Step [With Source Code] in 2025

Building a chatbot project in python with source code is one of the most exciting ways to dive into the world of Artificial Intelligence and Natural Language Processing (NLP). In 2025, chatbots are more than just novelties; they are essential tools for customer service, information retrieval, and user engagement across countless industries. Creating your own chatbot from scratch not only looks great on a resume but also provides a deep, hands-on understanding of how machines learn to understand and respond to human language. 

In this blog, we will walk you through every step of building a functional, intelligent chatbot. You'll learn the core concepts, from preparing the data to training an AI model and integrating it into a live chat application. We'll provide the complete source code and a detailed explanation, ensuring that even beginners can follow along and succeed. Get ready to bring your very own chatbot to life. 

Looking to build your career in one of the fastest-growing data science fields? Explore our online Data Science Course and gain the skills that employers are actively looking for all from the convenience of your home! 

Step-by-Step Guide: Your Chatbot Project in Python with Source Code 

Let's start building! Our chatbot will work by processing a knowledge base file, training a model to understand different categories of user queries, and then using that model to predict the best response. 

Prerequisites 

• Python 3.x installed on your computer. 
• A basic understanding of Python (variables, lists, dictionaries, functions). 
• pip, the Python package installer, which usually comes with Python. 

Step 1: Setting Up the Environment and Installing Libraries 

First, we need to install the necessary Python libraries. We'll use the Natural Language Toolkit (NLTK) for processing text and scikit-learn for building our classification model. 

Open your terminal or command prompt and run the following commands: 

Bash 
pip install nltk 
pip install scikit-learn 
 

We will also need to download a specific NLTK data package called punkt for tokenization and wordnet for lemmatization. Open a Python shell by typing python in your terminal, and then run this chatbot code: 

Python 
import nltk 
nltk.download('punkt') 
nltk.download('wordnet') 
 

Enhance your data science skills with the following specialized programs from upGrad to become industry-ready in 2025.  

• Executive Diploma in Data Science & AI 
• Generative AI Mastery Certificate for Data Analysis 
• Professional Certificate Program in Financial Modelling and Analysis in association with PwC Academy 

Step 2: Creating the Knowledge Base (intents.json) 

Our chatbot needs data to learn from. We'll create a JSON file named intents.json. This file will contain categories of user inputs (we'll call these "tags" or "intents"), patterns of what users might say for each intent, and a list of possible responses for the bot. 

Create a file named intents.json and add the following content: 

JSON 
{ 
  "intents": [ 
    { 
      "tag": "greeting", 
      "patterns": ["Hi", "Hello", "Hey", "Good morning", "Good afternoon"], 
      "responses": ["Hello!", "Hi there!", "Hey! How can I help you?"] 
    }, 
    { 
      "tag": "goodbye", 
      "patterns": ["Bye", "Goodbye", "See you later", "Take care"], 
      "responses": ["Goodbye!", "See you later!", "Take care!"] 
    }, 
    { 
      "tag": "thanks", 
      "patterns": ["Thanks", "Thank you", "That's helpful", "Thanks a lot"], 
      "responses": ["You're welcome!", "Happy to help!", "Any time!"] 
    }, 
    { 
      "tag": "about", 
      "patterns": ["Who are you?", "What are you?", "Tell me about yourself"], 
      "responses": ["I am a chatbot created with Python and NLTK.", "I'm your friendly neighborhood chatbot!"] 
    }, 
    { 
      "tag": "help", 
      "patterns": ["Help", "Can you help me?", "I need help", "What can you do?"], 
      "responses": ["I can answer your questions. What do you need help with?", "Sure, I'm here to help. What's up?"] 
    } 
  ] 
} 
 

You can add as many tags, patterns, and responses as you want to make your chatbot more knowledgeable. 

Also Read: How to Open a JSON File? A Complete Guide on Creating and Reading JSON 

Step 3: Preprocessing the Data 

Now we need to write a Python script to read this JSON file and prepare the data for training our model. This involves a few key NLP steps: 

1. Loading the data from the JSON file. 
2. Tokenization: Breaking down each sentence into individual words. 
3. Lemmatization: Reducing words to their base or root form (e.g., "running" becomes "run"). This helps the model treat different forms of the same word as the same thing. 
4. Creating a vocabulary and a bag-of-words representation for our training data. 

Let's start our Python script, which we'll call chatbot.py. 

Python 
import json 
import random 
import pickle 
import numpy as np 
 
import nltk 
from nltk.stem import WordNetLemmatizer 
 
from sklearn.feature_extraction.text import TfidfVectorizer 
from sklearn.linear_model import LogisticRegression 
 
lemmatizer = WordNetLemmatizer() 
 
# Load the intents file 
with open('intents.json') as file: 
    intents = json.load(file) 
 
words = [] 
classes = [] 
documents = [] 
ignore_letters = ['?', '!', '.', ','] 
 
# Process each intent 
for intent in intents['intents']: 
    for pattern in intent['patterns']: 
        # Tokenize each word in the sentence 
        word_list = nltk.word_tokenize(pattern) 
        words.extend(word_list) 
        # Add the pair to documents 
        documents.append((word_list, intent['tag'])) 
        # Add the tag to our classes list if not already there 
        if intent['tag'] not in classes: 
            classes.append(intent['tag']) 
 
# Lemmatize words and remove duplicates 
words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_letters] 
words = sorted(list(set(words))) 
classes = sorted(list(set(classes))) 
 
# Save the processed words and classes 
pickle.dump(words, open('words.pkl', 'wb')) 
pickle.dump(classes, open('classes.pkl', 'wb')) 
 
 

Step 4: Building and Training the Model 

With our data preprocessed, we can now create the training data and build our machine learning model. We will convert our text data into numerical vectors using TfidfVectorizer and then train a Logistic Regression classifier. This model will learn to predict the correct "tag" or "intent" for a given user input. This is a core part of completing a chatbot project in python with source code. 

Python 
# Create training data 
training = [] 
output_empty = [0] * len(classes) 
 
# Prepare documents for TF-IDF 
corpus = [" ".join(doc[0]) for doc in documents] 
tags = [doc[1] for doc in documents] 
 
# Vectorize the corpus 
vectorizer = TfidfVectorizer(tokenizer=lambda txt: [lemmatizer.lemmatize(w.lower()) for w in nltk.word_tokenize(txt) if w not in ignore_letters]) 
X = vectorizer.fit_transform(corpus) 
y = np.array(tags) 
 
# Train the Logistic Regression model 
model = LogisticRegression(random_state=42) 
model.fit(X, y) 
 
# Save the trained model and vectorizer 
pickle.dump(model, open('chatbot_model.pkl', 'wb')) 
pickle.dump(vectorizer, open('vectorizer.pkl', 'wb')) 
 
print("Training is complete!") 
 

After running this script, you will have four new files: words.pkl, classes.pkl, vectorizer.pkl, and chatbot_model.pkl. These files contain the processed data and the trained AI model, ready to be used. 

Step 5: Developing the Chatting Interface 

The final step is to create the functions that will handle the conversation. We need to: 

1. Take user input from the command line. 
2. Process that input in the same way we processed our training data. 
3. Use our trained model to predict the intent of the input. 
4. Select a random response from the list of responses for that intent. 
5. Display the response to the user. 

This step brings all our chatbot programming efforts together into a usable application. 

Python 
# This part of the code is for the interactive chat 
def get_response(user_input): 
    # Load the saved model, vectorizer, words, and classes 
    model = pickle.load(open('chatbot_model.pkl', 'rb')) 
    vectorizer = pickle.load(open('vectorizer.pkl', 'rb')) 
    classes = pickle.load(open('classes.pkl', 'rb')) 
 
    # Transform user input 
    user_input_vec = vectorizer.transform([user_input]) 
 
    # Predict the tag 
    prediction = model.predict(user_input_vec)[0] 
     
    # Get a random response from the predicted tag 
    for intent in intents['intents']: 
        if intent['tag'] == prediction: 
            response = random.choice(intent['responses']) 
            return response 
     
    return "I'm not sure how to respond to that." 
 
# Main chat loop 
print("Chatbot is live! Type 'quit' to exit.") 
while True: 
    message = input("You: ") 
    if message.lower() == 'quit': 
        break 
     
    response = get_response(message) 
    print(f"Bot: {response}") 
 

You can now run this entire script. The first part will train and save the model, and the second part will launch the interactive chat session in your terminal. 

Also Read: Top 50 Python Project Ideas with Source Code in 2025 

The Complete Chatbot Project in Python with Source Code 

For clarity and ease of use, here is the complete and final code for the project. 

File 1: intents.json 

JSON 
{ 
  "intents": [ 
    { 
      "tag": "greeting", 
      "patterns": ["Hi", "Hello", "Hey", "Good morning", "Good afternoon", "What's up"], 
      "responses": ["Hello!", "Hi there!", "Hey! How can I help you?"] 
    }, 
    { 
      "tag": "goodbye", 
      "patterns": ["Bye", "Goodbye", "See you later", "Take care", "I have to go"], 
      "responses": ["Goodbye!", "See you later!", "Take care!"] 
    }, 
    { 
      "tag": "thanks", 
      "patterns": ["Thanks", "Thank you", "That's helpful", "Thanks a lot", "Much appreciated"], 
      "responses": ["You're welcome!", "Happy to help!", "Any time!", "My pleasure!"] 
    }, 
    { 
      "tag": "about", 
      "patterns": ["Who are you?", "What are you?", "Tell me about yourself", "Your name?"], 
      "responses": ["I am a chatbot created with Python and NLTK.", "I'm your friendly neighborhood chatbot!", "You can call me Bot."] 
    }, 
    { 
      "tag": "help", 
      "patterns": ["Help", "Can you help me?", "I need help", "What can you do?", "Support"], 
      "responses": ["I can answer your questions based on my training. What do you need help with?", "Sure, I'm here to help. What's up?"] 
    }, 
    { 
      "tag": "name", 
      "patterns": ["What is your name?", "What should I call you?"], 
      "responses": ["You can call me ChatBot.", "I don't have a name, I am a bot."] 
    } 
  ] 
} 
 

File 2: chatbot.py (The Complete Python Script) 

Python 
import json 
import random 
import pickle 
import numpy as np 
import nltk 
from nltk.stem import WordNetLemmatizer 
from sklearn.feature_extraction.text import TfidfVectorizer 
from sklearn.linear_model import LogisticRegression 
 
# ----------------- 
# 1. DATA PREPARATION AND MODEL TRAINING 
# ----------------- 
def train_model(): 
    lemmatizer = WordNetLemmatizer() 
 
    # Load the intents file 
    with open('intents.json') as file: 
        intents = json.load(file) 
 
    words = [] 
    classes = [] 
    documents = [] 
    ignore_letters = ['?', '!', '.', ','] 
 
    # Process each intent 
    for intent in intents['intents']: 
        for pattern in intent['patterns']: 
            word_list = nltk.word_tokenize(pattern) 
            words.extend(word_list) 
            documents.append((word_list, intent['tag'])) 
            if intent['tag'] not in classes: 
                classes.append(intent['tag']) 
 
    # Lemmatize words, remove duplicates 
    words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_letters] 
    words = sorted(list(set(words))) 
    classes = sorted(list(set(classes))) 
 
    # Save the processed words and classes 
    pickle.dump(words, open('words.pkl', 'wb')) 
    pickle.dump(classes, open('classes.pkl', 'wb')) 
 
    # Prepare documents for TF-IDF 
    corpus = [" ".join(doc[0]) for doc in documents] 
    tags = [doc[1] for doc in documents] 
 
    # Vectorize the corpus 
    vectorizer = TfidfVectorizer(tokenizer=lambda txt: [lemmatizer.lemmatize(w.lower()) for w in nltk.word_tokenize(txt) if w not in ignore_letters]) 
    X = vectorizer.fit_transform(corpus) 
    y = np.array(tags) 
 
    # Train the Logistic Regression model 
    model = LogisticRegression(random_state=42, max_iter=200) 
    model.fit(X, y) 
 
    # Save the trained model and vectorizer 
    pickle.dump(model, open('chatbot_model.pkl', 'wb')) 
    pickle.dump(vectorizer, open('vectorizer.pkl', 'wb')) 
 
    print("Training is complete! Model and necessary files are saved.") 
    return intents 
 
# ----------------- 
# 2. CHATBOT INTERACTION 
# ----------------- 
def run_chatbot(intents): 
    # Load the saved model, vectorizer, and classes 
    model = pickle.load(open('chatbot_model.pkl', 'rb')) 
    vectorizer = pickle.load(open('vectorizer.pkl', 'rb')) 
 
    def get_response(user_input): 
        # Transform user input 
        user_input_vec = vectorizer.transform([user_input]) 
        # Predict the tag 
        prediction = model.predict(user_input_vec)[0] 
         
        # Get a random response from the predicted tag 
        for intent in intents['intents']: 
            if intent['tag'] == prediction: 
                response = random.choice(intent['responses']) 
                return response 
         
        return "I'm not sure how to respond to that, but I'm still learning." 
 
    # Main chat loop 
    print("\nChatbot is live! Type 'quit' to exit.") 
    while True: 
        message = input("You: ") 
        if message.lower() == 'quit': 
            break 
         
        response = get_response(message) 
        print(f"Bot: {response}") 
 
# ----------------- 
# MAIN EXECUTION 
# ----------------- 
if __name__ == "__main__": 
    trained_intents = train_model() 
    run_chatbot(trained_intents)

How to Enhance Your Python Chatbot 

You've successfully built a foundational chatbot project in python with source code. Now, let's explore some ways to make it even better. 

1. Add a Graphical User Interface (GUI) 

A command-line interface works, but a graphical chat window is far more engaging. You can use Python's built-in Tkinter library to create a simple GUI. 

Example Snippet: 

Python 
import tkinter as tk 
 
def setup_gui(): 
    # This is a basic structure for a GUI 
    window = tk.Tk() 
    window.title("My Chatbot") 
     
    chat_history = tk.Text(window, state='disabled') 
    chat_history.pack(padx=10, pady=10) 
     
    message_entry = tk.Entry(window, width=50) 
    message_entry.pack(padx=10, pady=5) 
     
    send_button = tk.Button(window, text="Send") 
    send_button.pack(pady=5) 
     
    window.mainloop() 
     
# You would integrate your chatbot logic with this GUI 
# setup_gui() 
 

2. Connect to a Database 

To make your chatbot remember conversations or user preferences, you can connect it to a database like SQLite. You could store each conversation with a timestamp, allowing you to analyze what users are asking most frequently. 

3. Deploy Your Chatbot on a Website 

You can turn your chatbot into a web application using a web framework like Flask or Django. This would allow you to create an API that a website's frontend can communicate with, letting users interact with your chatbot directly in their browser. 

Also Read: The Ultimate Guide to Python Web Development: Fundamental Concepts Explained 

4. Use More Advanced NLP Models 

While our model works well, you can achieve even more human-like conversations using state-of-the-art models. The Hugging Face Transformers library provides easy access to powerful pre-trained models like BERT and GPT-2, which can understand context and nuance far better. This is a great next step after mastering the fundamentals of chatbot code. 

Also Read: Natural Language Processing: The Only Guide You'll Ever Need! 

Understanding the Core of a Python Chatbot 

Now, let's understand what a chatbot is and why Python is the perfect tool for the job. A chatbot is a computer program designed to simulate human conversation through text or voice commands. The goal is to create a program that a user can interact with in a natural, intuitive way. 

Types of Chatbots 

There are generally two types of chatbots: 

1. Rule-Based Chatbots: These are the simplest form. They operate based on a predefined set of rules. If a user's query matches a specific keyword or pattern, the bot responds with a pre-written answer. They are easy to build but not very flexible. 
2. AI/ML-Based Chatbots: These are more advanced. They use Machine Learning (ML) and Natural Language Processing (NLP) to understand the intent behind a user's query, not just the keywords. They can handle variations in language and learn from conversations to improve over time. 

In this tutorial, we will build an AI-based chatbot. It will be simple enough for beginners but powerful enough to understand user intent and provide intelligent responses. This approach provides a solid foundation in chatbot programming. 

Why Use Python for Chatbot Development? 

Python is the undisputed king of AI and Machine Learning for several reasons: 

• Simple Syntax: Python's code is clean and readable, making it easy for beginners to learn and write. 
• Extensive Libraries: It has a massive ecosystem of libraries specifically for AI and NLP, such as NLTK, TensorFlow, PyTorch, and scikit-learn. These libraries simplify complex tasks, allowing us to focus on the logic of our chatbot. 
• Strong Community: A large and active community means you can always find tutorials, documentation, and support when you get stuck. 

Conclusion 

Congratulations on completing your chatbot project in python with source code! You have successfully built an intelligent application that can understand and respond to human language. You've learned the entire pipeline of a chatbot project, from gathering and preprocessing data with NLTK to training a machine learning model with scikit-learn and building an interactive user interface. 

Discover popular AI and ML blogs and free courses to deepen your expertise. Explore the programs below to find your perfect fit.

Popular AI and ML Blogs & Free Courses