How to Make a Chatbot Project in Python [With Source Code] in 2026

A Chatbot Project in Python lets you build a program that understands user input, responds intelligently, and automates conversations. You can create one using simple rule-based logic, machine-learning models, or NLP tools like NLTK and spaCy. 

With Python’s clean syntax, you can handle text processing, intent detection, and response generation in a structured, step-by-step way. You also get full control over how the chatbot behaves, learns, and interacts with users.
In this guide, you'll see a full chatbot project in python with source code along.

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 

If you have ever wondered how to make a chatbot in python that actually learns, you are in the right place. The following steps will help you set up the environment required to run the chatbot using python source code provided later in this guide.

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 

The foundation of any efficient chat bot python application lies in its libraries. By installing NLTK and scikit-learn, you are equipping your system with the tools needed to learn how to make chatbot in python effectively.

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') 
 

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

This data structure is the 'brain' of our bot. The JSON format below is a standard approach for a simple chatbot in python source code.
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 

Below, you will find the full chatbot source code in python. We have combined the training and chat execution into a single flow. You can copy this chatbot in python source code directly into your IDE to see it in action.

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)

Enhancing the Chatbot Project in Python

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 has emerged as the leading language for Artificial Intelligence and Natural Language Processing (NLP). If you are wondering how to make a chatbot in python, here is why it is the best choice for developers and students alike:

• Simplicity and Readability: Python’s syntax is clear and concise, making it the ideal language for beginners starting a chatbot project in python. Unlike more complex languages, you can focus on the logic of conversation rather than struggling with verbose syntax, which is perfect when you are looking for a simple chatbot project in python with source code to get started quickly.
• Powerful NLP Libraries: The primary reason developers prefer building a chatbot using python is its massive ecosystem. Libraries like NLTK (Natural Language Toolkit), spaCy, and TensorFlow allow you to build a sophisticated chat bot python application without reinventing the wheel.
• Scalability: What starts as a basic script can grow. You can take a standard chat bot using python source code and scale it into a fully functional AI assistant capable of handling thousands of queries, bridging the gap between a student project and a professional application.

Common Errors & Troubleshooting

Even when working with a straightforward script, errors can happen. Here are common issues developers face when running this chatbot project with source code and how to fix them:

• Indentation Errors: Python is very strict about spacing. If you copy-paste the simple chatbot code in python and see an IndentationError, ensure that all lines inside functions and loops are aligned correctly. Even a single misplaced space can prevent the script from running.
• Missing Libraries: Before executing the chatbot source code in python, double-check that you have installed nltk and scikit-learn. If you get a ModuleNotFoundError, simply run pip install nltk scikit-learn in your terminal again.
• JSON File Path: The bot relies on intents.json to understand user queries. If the chatbot in python source code cannot find this file, it will crash. Ensure that the JSON file is in the exact same folder as your Python script.
• "Punkt" or "Wordnet" Not Found: This is a classic error when learning how to make a ai chatbot in python. The NLTK library requires specific data packages to be downloaded separately. Make sure you included the lines nltk.download('punkt') and nltk.download('wordnet') at the start of your script.
• Pickle Version Conflicts: If you trained your model on one computer and tried to run the chatbot source code in python on another, you might face issues with the pickle files. It is best to re-run the training function train_model() whenever you switch environments to ensure compatibility.

Conclusion 

Congratulations on completing your chatbot project in python with source code! We hope this chatbot project with source code has given you a solid foundation in NLP.  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.