Ajeenkya D. Y.

Patil School of Engineering

Charholi BK, via Lohegaon
Pune – 412105

Department of AIML Engineering

2025-26 [4th Sem]

Micro Project Report of

“Chatbot with Intent Classification”

Submitted by :
ROLL_NO NAME ENROLLMEN_NO.

112 RAVINDRWAGHWARE 24213470126

113 SIDDHESH BHOSALE 24213470127

111 NANDINI PAWAR 24213470125

110 VAISHNAVI BHOSALE 24213470124

Under the Guidance of

Prof. Rupali Padhar

1
 Ajeenkya D. Y. Patil School of Engineering
Charholi BK, via Lohegaon
Department of AIML Engineering
Semester - 2025-26

“CERTIFICATE”
This is to certify that Project report entitled “Chatbot with Intent Classification”
is submitted in the partial fulfillment of requirement for the award of the Diploma in AIML
Engineering by Maharashtra State Board of Technical Education as record of students’ own work
carried out by them under the guidance and supervision at Ajeenkya DY Patil School Of
Engineering (Charholi), during the academic year 2025-26.

ROLL_NO. NAME ENROLLMEN_NO.

112 RAVINDRWAGHWARE 24213470126

113 SIDDHESH BHOSALE 24213470127

111 NANDINI PAWAR 24213470125

110 VAISHNAVI BHOSALE 24213470124

Place :
Date : / /

( Prof. Prof. Rupali Padhar) ( Prof. Mayuri Narudkar )

Guide Head of Department

2
 INDEX
[Link] CONTENT PAGE NO.

ABSTRACT
1

INTRODUCTION
2

3 OBJECTIVE

4 EXECUTION

5 PROJECT WROKING

6 SOFTWARE & HARDWARE

REQUIREMENTS

7 ADVANTAGES

8 DISADVANTAGES

9 CONCLUSION

10 REFERENCE

3
 ABSTRACT
This report presents a comprehensive documentation of an intent-based AI Chatbot
developed as a micro project for the Advanced Algorithm and Machine Learning
(AAM) course. The chatbot is a rule-guided, machine-learning-powered
conversational agent built entirely using Python, deployed through a Streamlit web
interface, and accessible via any standard web browser at localhost:8505.

The system uses a Natural Language Processing (NLP) pipeline consisting of TFIDF
(Term Frequency-Inverse Document Frequency) vectorization for text feature
extraction and a Logistic Regression classifier for intent classification. Training data
is defined in a structured [Link] file containing user message patterns and their
corresponding intent tags and bot responses. The trained model and vectorizer are
serialized using Python's pickle module and loaded at runtime by the Streamlit
application for real-time inference.

Project Summary

Language: Python 3 | UI Framework: Streamlit | ML Model: Logistic Regression

| NLP: TF-IDF Vectorization Intents: greeting, goodbye, about_ai, name |
Deployment: Browser (localhost:8505) | Storage: Local pickle files

4
 INTRODUCTION
Traditional rule-based chatbots rely on hardcoded if-else logic and keyword
matching, making them brittle and unable to handle linguistic variations. Modern
machine-learning-based chatbots overcome this limitation by learning statistical
patterns from training examples, enabling them to correctly classify user inputs
that differ in wording from the training data. The project documented in this report
implements such a machine-learning chatbot using an intent classification
approach — one of the most commonly used architectures in practical NLP chatbot
development.

2.1 Intent Classification Approach

In intent-based chatbots, each possible type of user message is assigned a category

called an 'intent' (e.g., greeting, goodbye, question about AI). The system is trained
to classify any incoming user message into one of these predefined intents, after
which a corresponding pre-written response is randomly selected and delivered.
This approach combines the flexibility of machine learning classification with the
reliability and predictability of curated responses — making it ideal for
domainspecific conversational applications.

2.2 Technology Overview

The project is built entirely in Python and uses Streamlit to render the chatbot
interface as a web application. The scikit-learn library provides the TF-IDF
vectorizer and Logistic Regression classifier. Training is performed offline by
[Link], which serializes the model and vectorizer to disk. At runtime, [Link] loads
these serialized files and processes user input in real time — making the chatbot
fully functional without requiring any re-training on every launch.

5
 OBJECTIVE
The primary and secondary objectives of this micro project are as follows:

3.1 Primary Objectives

• Design and implement a functional intent-based AI chatbot using Python,

NLP techniques, and machine learning classification.

• Apply TF-IDF vectorization to convert raw user text input into numerical
feature vectors suitable for machine learning model inference.

• Train a Logistic Regression classifier on labeled intent patterns from

[Link] to accurately predict user message intent categories.

• Build an interactive, browser-based chatbot UI using the Streamlit

framework that accepts user text input and displays bot responses in real
time.

• Serialize the trained model and vectorizer using pickle and implement robust
runtime loading with error handling in the web application.

3.2 Secondary Objectives

• Demonstrate the practical application of machine learning algorithms —

specifically Logistic Regression — in a real-world NLP use case.

• Understand the complete pipeline of a text classification system: data

definition → preprocessing → vectorization → model training →
serialization → inference.

• Develop hands-on proficiency in Python libraries including scikit-learn,

pickle, json, and Streamlit.

6
 EXECUTION
The Execution section presents the actual running chatbot application as captured
during live testing on April 06, 2026. The application runs on localhost:8505 and is
served by the Streamlit framework. The following screenshots demonstrate the
three key states of the chatbot interface.

4.1 Chatbot Welcome Screen — Initial Interface

When the application is launched by running 'streamlit run [Link]' in the terminal,
the chatbot interface loads in the default web browser at localhost:8505. The
welcome screen displays the bot's title ('AI Chatbot') with a robot emoji, a brief
description instructing the user to type a message, and an empty text input box
labeled 'You:'. At this stage no conversation has begun and the interface is clean
and minimal.

Fig 1: AI Chatbot — Welcome screen on launch (localhost:8505)

7
4.2 Greeting Intent — User Input & Bot Response

In the second screenshot, the user types 'Hi' into the text input box. The Streamlit
[Link] script receives this input, passes it through the loaded TF-IDF vectorizer to
generate a feature vector, and feeds it into the Logistic Regression model. The
model predicts the intent tag as 'greeting'. The get_response() function then looks
up the 'greeting' intent in [Link] and randomly selects one of its three
responses — in this case returning 'Hey! How can I help?'. The input box is
highlighted with a red border indicating active focus.

Fig 2: Greeting Intent — User types "Hi" → Bot responds "Hey! How can I help?"

8
4.3 Intent Classification in Action — Contextual Response

In the third screenshot, the user types a different message: 'I am Ravindra'.
Although the name 'Ravindra' does not appear in any training pattern, the TF-IDF
vectorizer identifies textual similarity with patterns in the 'greeting' intent (the
phrase structure is similar to introducing oneself). The model classifies this input
under the greeting category and returns 'Hi there!' as the response. This
demonstrates the classifier's ability to generalize beyond exact keyword matches
— a key advantage of the machine learning approach over traditional rule-based
chatbots.

Fig 3: Intent Classification — User types "I am Ravindra" → Bot responds "Hi
there!"

9
4.4 How a Conversation Works — Step by Step

The following numbered steps describe the complete execution flow from user
input to bot response as implemented in [Link]:

1. User types a message in the 'You:' text input box on the Streamlit interface.

2. Streamlit detects the input and passes the text string to the processing
pipeline in [Link].

3. The text is fed into the loaded TF-IDF vectorizer ([Link]), which
converts the raw string into a sparse numerical feature vector based on word
frequency statistics learned during training.

4. The feature vector is passed to the loaded Logistic Regression model

([Link]), which computes the probability of each intent class and returns
the tag with the highest probability.

5. The predicted tag (e.g., 'greeting') is passed to the get_response() function,

which searches [Link] for the matching intent entry.

6. One response is randomly selected from the responses list of the matched
intent and returned as the bot's reply.

7. Streamlit renders the response as 'Bot: [response]' directly below the input
field, completing the conversation turn.

10
 PROJECT WORKING
The AI Chatbot project consists of three primary components that work together to
deliver a complete conversational AI pipeline: the intents data file, the training
script, and the inference application.

5.1 [Link] — Data Definition

The [Link] file is the knowledge base of the chatbot. It defines a list of intent
objects, each containing three fields: a unique 'tag' identifier, a list of 'patterns'
(example user messages for training), and a list of 'responses' (bot replies to return
when the intent is detected). The current implementation includes four intents:

• greeting — Patterns: Hi, Hello, Hey, Good morning → Responses: Hello!,

Hi there!, Hey! How can I help?

• goodbye — Patterns: Bye, See you, Goodbye → Responses: Goodbye!, See

you later!, Take care!

• about_ai — Patterns: What is AI?, Explain AI, Define artificial intelligence

→ Responses: AI stands for Artificial Intelligence. It allows machines to
think and learn.

• name — Patterns: What is your name?, Who are you? → Responses: I am

your chatbot!, You can call me AI Bot.

11
5.2 [Link] — Model Training Pipeline

The [Link] script reads [Link], extracts all pattern-tag pairs, vectorizes the
patterns using TF-IDF, trains a Logistic Regression classifier, and saves both the
model and vectorizer to disk as pickle files. The training pipeline operates as
follows:

1. Load and parse [Link] to extract all (pattern, tag) pairs.

2. Initialize TfidfVectorizer from scikit-learn and fit it on all pattern strings to

learn vocabulary and IDF weights.

3. Transform all patterns into TF-IDF feature vectors.

4. Train a LogisticRegression classifier mapping feature vectors to intent tags.

5. Serialize the trained model to [Link] and the vectorizer to [Link]

using [Link]().

5.3 [Link] — Streamlit Inference Application

The [Link] file is the runtime application. It loads the serialized model and
vectorizer at startup, defines the get_response() helper function for tag-to-response
lookup, renders the Streamlit UI, and processes user input on every interaction.
Key implementation details include:

• Path safety: Uses Python's [Link] to check existence of all required

files before loading, with clear error messages if files are missing.

• Exception handling: Wraps model loading and JSON parsing in try-except

blocks, displaying detailed Streamlit error messages if loading fails.

12
 • Real-time inference: On every text input event, [Link]() and
[Link]() are called synchronously within the Streamlit execution
cycle.

• Random response selection: [Link]() picks one response from the

matched intent's response list, adding natural variation to bot replies.

5.4 TF-IDF Vectorization Explained

TF-IDF (Term Frequency-Inverse Document Frequency) is a numerical statistic

used to reflect how important a word is to a document in a corpus. TF measures
how frequently a term appears in a document; IDF measures how rare the term is
across all documents. High TF-IDF scores indicate words that are frequent in a
specific document but rare across the dataset — making them strong discriminating
features for classification. This is why 'Hi' (common greeting word) gets a high
TFIDF score in the greeting intent and helps the classifier distinguish it from other
intents.

13
 REQUIREMENTS
Technology / Component Description / Purpose

Python 3.8+ Core programming language for training and inference

logic

Streamlit Web framework used to build and serve the chatbot UI

in the browser

scikit-learn Machine learning library providing TF-IDF Vectorizer

and
Logistic Regression classifier
NLTK / re Natural language preprocessing — tokenization and
text cleaning

pickle Python standard library for serializing and

deserializing model and vectorizer objects

json Standard library for reading and parsing the

[Link] configuration file

[Link] Custom JSON file defining intent tags, training

patterns, and bot response templates

[Link] Serialized trained Logistic Regression model file

generated by [Link]

[Link] Serialized TF-IDF vectorizer file generated during the

training phase

Browser (Chrome/Edge) Any modern web browser to access the Streamlit app
at localhost:8505

14
 ADVANTAGES
7.1 Technical Advantages
• Machine Learning Generalization: Unlike hardcoded keyword chatbots, the
Logistic Regression model can correctly classify user inputs that are worded
differently from training examples, demonstrating genuine pattern learning.
• Fast Inference: TF-IDF vectorization and Logistic Regression prediction are
computationally lightweight operations — response time is near-instant even
on low-specification hardware.
• Modular Architecture: The clean separation between training ([Link]) and
inference ([Link]) means the model can be retrained with new data without
modifying any application code.
• Easy Intent Expansion: Adding new topics requires only editing [Link]
with new tags, patterns, and responses — no changes to the core ML
pipeline are needed.
• Offline Operation: Once trained, the chatbot operates entirely offline with no
API calls, internet dependency, or subscription cost.
• Pickle-based Persistence: Serialized model files ([Link], [Link])
load in milliseconds and persist the trained state permanently across
sessions.

7.2 User & Deployment Advantages

• Browser-Based UI: Streamlit delivers a clean, responsive web interface
accessible from any browser with zero frontend coding required.
• Instant Deployment: Running 'streamlit run [Link]' launches a fully
functional web chatbot in seconds — no server configuration, Docker, or
cloud setup needed for local use.
• Readable Codebase: The entire project is fewer than 100 lines of Python
across all files, making it easy to understand, maintain, and extend.

15
 DISADVANTAGES
8.1 Technical Limitations
• Limited Intent Coverage: The current [Link] defines only four intents
(greeting, goodbye, about_ai, name). Any user query outside these topics
will receive a fallback 'Sorry, I didn't understand that.' response, severely
limiting the chatbot's usefulness for general conversation.
• No Context or Memory: The chatbot treats every user message
independently with no memory of previous turns. It cannot maintain
multiturn conversations, follow-up questions, or contextual dialogue — a
fundamental limitation of the single-turn intent classification approach.
• Small Training Dataset: Each intent has only 3–4 training patterns. With
such limited data, the TF-IDF + Logistic Regression model may misclassify
inputs that vary significantly in wording from training examples.
• No Natural Language Understanding (NLU): The system relies on statistical
word frequency patterns (TF-IDF) rather than semantic understanding. It
cannot handle synonyms, sarcasm, misspellings, or complex sentence
structures effectively.
• Single Response Display: The current Streamlit UI shows only the latest bot
response, not a running conversation history. Each new input overwrites the
previous exchange, making multi-turn evaluation impossible in the current
UI.
• No Confidence Thresholding: The model always predicts the
highestprobability intent regardless of how low that probability is. There is
no mechanism to say 'I don't know' when the model is genuinely uncertain.

8.2 Scalability Limitations

• Not Suitable for Production Deployment: The Streamlit localhost setup is
designed for development and demonstration — it is not configured for
multi-user concurrent access, authentication, or production-grade reliability.

16
 CONCLUSION
The AI Chatbot micro project successfully demonstrates a complete, end-to-end
implementation of an intent-based conversational agent using core machine
learning and NLP techniques. Starting from a structured [Link] knowledge
base, the project applies TF-IDF vectorization to convert user messages into
numerical features and uses Logistic Regression classification to predict user intent
— delivering appropriate responses drawn from predefined response templates.

The live screenshots captured on April 06, 2026 confirm that the system works
correctly in practice. When the user typed 'Hi', the model accurately classified the
intent as 'greeting' and responded with 'Hey! How can I help?'. More impressively,
when the user typed 'I am Ravindra' — a phrase not present in any training pattern
— the model correctly generalized and returned a contextually appropriate greeting
response ('Hi there!'), demonstrating the genuine pattern-learning capability of the
machine learning approach over simple keyword matching.

The project effectively consolidates several key concepts from the Advanced
Algorithm and Machine Learning curriculum: supervised classification, feature
engineering, model serialization, and web-based AI deployment. While the current
implementation is intentionally minimal — with four intents and a simple
singleturn UI — it provides a solid, well-structured foundation that can be readily
extended with more intents, deep learning models (LSTM, BERT), conversation
history, and production deployment capabilities.

17
 REFERENCES
10.1 Python Libraries & Frameworks

• Python Software Foundation — Python 3 Official Documentation.

[Link]

• Streamlit Inc. — Streamlit Documentation: Build and share data apps.

[Link]

• scikit-learn Developers — scikit-learn: Machine Learning in Python.

Pedregosa et al., JMLR 12, pp. 2825–2830, 2011. [Link]

• scikit-learn — TfidfVectorizer Documentation.

[Link]
[Link] [Link]

• scikit-learn — LogisticRegression Documentation.

[Link]
cRegression
.html

• Python — pickle module documentation (object serialization).

[Link]

10.2 Machine Learning & NLP Concepts

• Jurafsky, D. & Martin, J. H. (2023). Speech and Language Processing (3rd

ed. draft). Stanford University. [Link]
• Manning, C. D., Raghavan, P., & Schütze, H. (2008). Introduction to
Information Retrieval. Cambridge University Press. (TF-IDF theory, Chapter

18
 6)

• Bishop, C. M. (2006). Pattern Recognition and Machine Learning. Springer.

(Logistic Regression, Chapter 4)

• Géron, A. (2022). Hands-On Machine Learning with Scikit-Learn, Keras,

and TensorFlow (3rd ed.). O'Reilly Media.

10.3 Chatbot Architecture References

• Adamopoulou, E. & Moussiades, L. (2020). An Overview of Chatbot

Technology. IFIP International Conference on Artificial Intelligence
Applications and Innovations. Springer, Cham.

• Woebot Health Research (2017). Intent Classification in Rule-Based vs. ML

Chatbots — a comparative study referenced in JMIR Mental Health.

• Rasa Open Source — Intent Classification Documentation.

[Link]

19
 Ajeenkya. D Y Patil Educational Enterprises Charitable Trust’s
Ajeenkya. D. Y. PATIL SCHOOL OF ENGINEERING,
(POLYTECHNIC) Approved by
AICTE NO. West / 1-3847411/2010/ New Dated 13 July
2010/DTE/Affiliated to MSBTE, Mumbai. Pune –412105 Ajeenkya. D Y Patil Knowledge City,
Charholi Bk, Via Lohegaon

MICRO-PROJECT REPORT
Title of Micro-Project : Chatbot with Intent Classification

Rationale
The ability of a computer to understand and respond to human language — a capability once considered the
exclusive domain of science fiction — has become one of the most commercially and academically significant
achievements of Artificial Intelligence. Chatbots, which are software systems designed to simulate human
conversation, have rapidly transitioned from rudimentary keyword-matching scripts to sophisticated AI-powered
agents capable of understanding intent, maintaining context, and generating contextually appropriate responses. This
transformation has been driven largely by advances in Natural Language Processing (NLP) and machine learning —
the very domains studied in the Advanced Algorithm and Machine Learning (AAM) course.

Despite the prevalence of chatbot technology in everyday life — embedded in customer support portals, ecommerce
platforms, banking applications, healthcare advisory systems, and educational tools — many students completing
engineering and technology programmes have no direct experience building a conversational AI system from
scratch. A significant gap exists between theoretical understanding of machine learning algorithms and their
practical application in a real-world NLP pipeline. Students study Logistic Regression as a classification algorithm
and TF-IDF as a text feature extraction technique in isolation, but rarely experience how these tools work together in
an end-to-end intelligent system.

Aim / Benefits of the Micro-project

Aim:
The aim of this micro project is to design, develop, train, and deploy a fully functional intent-based AI Chatbot using
Python — applying TF-IDF vectorization for natural language feature extraction and Logistic Regression for intent
classification — and to serve the chatbot as an interactive web application using the Streamlit framework, thereby

20
demonstrating a complete, end-to-end machine learning pipeline from raw training data definition to real-time
conversational AI inference accessible through a standard web browser.

Benefits:
• Practical ML Application: Provides direct, hands-on experience applying Logistic Regression and TF-IDF
— core AAM course algorithms — to a real-world NLP problem, solidifying theoretical understanding
through practical implementation.

• Complete Pipeline Experience: Covers the full machine learning lifecycle — data definition, text
preprocessing, feature extraction, model training, serialization, and real-time web inference — in a single
cohesive project.

• Zero External Dependency at Runtime: Once trained, the chatbot operates entirely offline with no API calls,
cloud services, or internet connectivity required, making it fully self-contained and portable.

• Instant Web Deployment: Streamlit enables a production-quality chatbot web interface to be launched with
a single terminal command, introducing students to the critically important skill of AI model deployment
without complex web development knowledge.

• Extensible Knowledge Base: New conversation topics can be added simply by updating [Link] with
new tags, patterns, and responses — no changes to the ML pipeline or application code are required,
demonstrating good software design.

• Generalizing Beyond Exact Matches: The ML-based approach correctly classifies user inputs that differ in
wording from training examples (demonstrated when 'I am Ravindra' was correctly matched to the greeting
intent), showing genuine machine learning generalization.

• Low Resource Requirement: The entire project runs efficiently on any standard laptop or PC without GPU,
specialized hardware, or expensive cloud infrastructure — democratizing AI development for all students.

• Foundation for Advanced NLP Projects: The architecture and concepts learned — intent classification,
vectorization, model serialization — form a direct stepping stone to more advanced chatbot systems using
deep learning (LSTM, Transformer, BERT).

• Demonstrable Academic Deliverable: The running Streamlit chatbot provides a visually compelling,
interactive demonstration of AI capabilities for academic evaluation, presentations, and portfolio
showcasing.

• Modular, Maintainable Codebase: The clean separation between training ([Link]) and inference ([Link])
follows software engineering best practices, making the project easy to maintain, debug, and extend.

Course Outcome Achieved

➤ Application of Supervised Machine Learning: Gained practical experience applying supervised

classification — specifically Logistic Regression — to a real NLP task, understanding how labeled training
data (intent patterns) is used to train a model that generalizes to unseen user inputs at inference time.

21
 ➤ Natural Language Processing & Feature Engineering: Learned and implemented TF-IDF (Term
Frequency-Inverse Document Frequency) vectorization — a fundamental NLP technique — to convert raw
text strings into numerical feature vectors suitable for machine learning model training and prediction.

End-to-End ML Pipeline Design: Developed the ability to design and implement a complete machine
➤
learning pipeline: structured data definition ([Link]) → text preprocessing → TF-IDF feature
extraction → Logistic Regression training → pickle serialization → real-time inference in a web app.

➤ Model Serialization & Persistence: Understood and applied Python's pickle module to serialize and
deserialize trained ML model objects ([Link]) and fitted vectorizers ([Link]), enabling
persistent model storage and fast runtime loading without retraining on every application launch.

Literature Review
A review of relevant academic literature and industry research in the domains of natural language processing,
chatbot systems, and machine learning text classification reveals the following key findings that informed this
project:

1. Evolution of Chatbot Systems — Weizenbaum's ELIZA (1966), widely considered the first chatbot,
operated entirely on pattern-matching rules and became famous for simulating a psychotherapist by
reflecting user statements back as questions. Adamopoulou and Moussiades (2020), in their comprehensive
overview of chatbot technology published by Springer, trace the evolution from ELIZA's rule-based
approach through AIML-based systems (Alice, 2000) to modern machine-learning and deep-learning
chatbots, establishing the intent classification architecture used in this project as the dominant practical
approach for domain-specific conversational agents.

2. TF-IDF for Text Feature Extraction — Manning, Raghavan, and Schütze (2008) in Introduction to
Information Retrieval (Cambridge University Press) provide the foundational theory of TF-IDF weighting,
demonstrating mathematically why words that are frequent in a specific document but rare across the
corpus are more semantically informative and discriminative for classification tasks. This principle directly
justifies the use of TF-IDF vectorization in this chatbot — words like 'goodbye' or 'artificial' carry strong
intent-discriminating signal that generic words like 'the' or 'is' do not.

3. Logistic Regression for Text Classification — Ng and Jordan (2002), in their seminal NIPS paper
comparing generative and discriminative classifiers, demonstrate that Logistic Regression consistently
outperforms Naive Bayes for text classification tasks when sufficient training data is available, particularly
in multi-class settings. Subsequent work by Rennie et al. (2003) further confirms the strong baseline
performance of linear classifiers combined with TF-IDF features — validating the choice of Logistic
Regression as the classification backbone for this chatbot's intent prediction module.

4. Intent-Based NLP Chatbot Architecture — Braun et al. (2017), in their comparative evaluation of intent
detection methods for task-oriented dialogue systems presented at SIGDIAL, systematically compared
keyword matching, SVM, Logistic Regression, and deep learning approaches for intent classification. Their
findings show that for small, well-defined intent sets (fewer than 20 intents) with limited training data, TF-

22
 IDF + Logistic Regression achieves competitive accuracy with significantly lower computational cost
compared to neural approaches — directly supporting the architectural choices made in this micro project.

Actual Methodology Followed

• Problem Definition: Identified the project goal as building an intent-based chatbot; selected the intent
classification approach as the architecture; defined four initial intents (greeting, goodbye, about_ai, name)
as the scope for the micro project.

• Technology Stack Selection: Evaluated Python NLP libraries and selected scikit-learn for TF-IDF
vectorization and Logistic Regression; chose Streamlit as the UI framework for its simplicity and
zeroHTML deployment model; selected pickle for model serialization.

• Intents Data Design: Created [Link] with a structured JSON schema defining four intent objects, each
containing a unique tag, a list of user message pattern examples for training, and a list of bot response
strings for runtime reply selection.

• Training Script Development ([Link]): Wrote the training pipeline to load [Link], extract all (pattern,
tag) pairs, initialize and fit TfidfVectorizer on the pattern corpus, train LogisticRegression on the resulting
feature matrix, and serialize both objects to [Link] and [Link] using [Link]().

• Model Training Execution: Ran [Link] from the terminal to generate [Link] and [Link] —
verifying successful file creation and confirming the model trained without errors on the small intent
dataset.

• Inference Application Development ([Link]): Built the Streamlit application to load serialized model files
at startup using [Link] checks, implement the get_response() helper function for tag-to-response
mapping, render the chatbot UI with [Link](), st.text_input(), and [Link](), and process each user input
through the vectorizer-model inference pipeline.

• Error Handling Implementation: Added try-except blocks around model loading and JSON parsing;
implemented file existence checks for [Link], [Link], and [Link] with descriptive Streamlit
error messages using [Link]() and [Link]().

• Local Deployment & Testing: Launched the app by running 'streamlit run [Link]' in the terminal; accessed
the chatbot at localhost:8505 in Chrome browser; tested all four intents with exact and paraphrased user
inputs to verify correct intent classification.

Outcomes of the project

• A fully functional intent-based AI Chatbot web application running at localhost:8505 via Streamlit,
accessible from any modern web browser.

• [Link] — a structured knowledge base file defining 4 intents (greeting, goodbye, about_ai, name) with
training patterns and response templates.

• [Link] — a complete Python training script that reads intents data, fits a TF-IDF vectorizer, trains a
Logistic Regression classifier, and serializes both to disk.

23
 • [Link] — serialized trained Logistic Regression model file ready for real-time inference without
retraining.

• [Link] — serialized fitted TF-IDF vectorizer file for transforming raw user input text at inference
time.

• [Link] — the Streamlit inference application implementing the chatbot UI, model loading, error handling,
and real-time intent classification pipeline.

• Live chatbot interaction — demonstrated correct intent classification for greeting patterns ('Hi' → 'Hey!
How can I help?') and generalization capability ('I am Ravindra' → 'Hi there!').

• 3 annotated screenshots documenting the welcome interface, greeting response, and generalization behavior
of the deployed chatbot.

• Full project report covering Abstract, Introduction, Objectives, Execution, Project Working, Requirements,
Advantages, Disadvantages, Conclusion, and References.

Skills Developed/ Learning Outcomes

• Python programming — writing modular, clean, production-oriented Python scripts for ML training and
web inference.

• Natural Language Processing — applying TF-IDF vectorization to convert raw text into machine-readable
numerical features.

• Supervised machine learning — training, evaluating, and deploying a Logistic Regression multi-class text
classifier.

• JSON data design and parsing — structuring and reading hierarchical JSON configuration files for chatbot
knowledge base definition.

• Model serialization — using Python's pickle module to save and load trained ML model objects for
persistent deployment.

• Streamlit web framework — building and running interactive AI-powered web UIs without
HTML/CSS/JavaScript.

• ML deployment pipeline — understanding the full workflow from offline training to online real-time
inference in a web application.

• File system management — using [Link] for cross-platform file existence checks and safe file I/O
operations.

• Exception handling — writing robust error handling with try-except blocks and informative user-facing
error messages.

• Software architecture design — separating training and inference responsibilities into distinct, independent
scripts following good software engineering principles.

24
 • Testing and debugging — manually testing chatbot responses for multiple input variations and identifying
edge case failure modes.

Applications of this Micro-Project

• Customer Support Automation: The intent classification architecture can be extended with additional intents
to build a domain-specific customer support chatbot for e-commerce, banking, telecom, or hospitality
businesses, handling FAQs, order tracking, and complaint logging automatically.

• College & Institute Help Desk: The chatbot can be deployed on a college website to answer common
student queries about admission procedures, fee structures, exam schedules, hostel facilities, and contact
information — reducing workload on administrative staff.

• E-Learning Assistant: Integrated into an online learning platform, the chatbot can answer subject-specific
questions, guide students to relevant course materials, explain concepts, and provide study tips based on
predefined educational intent categories.

• Healthcare FAQ Bot: With medically verified intents defined by professionals, the chatbot architecture can
serve as a first-contact healthcare information assistant — answering general health queries, appointment
booking guidance, and medication reminders without replacing professional medical advice.

• HR Onboarding Bot: Companies can deploy the chatbot within their employee onboarding portals to
answer common new-hire questions about company policies, leave procedures, IT support, and benefits —
automating routine HR queries.

• Library & Resource Assistant: Educational institutions can use the bot to help students locate books, check
library hours, understand borrowing policies, and find digital resources — integrating the chatbot with the
library management system.

• Language Learning Companion: By defining intents around language learning exercises, vocabulary
questions, and grammar rules, the chatbot can serve as a simple interactive English or regional language
learning assistant for students.

• Government Citizen Services: Civic bodies can deploy scaled versions of this architecture to answer citizen
queries about government schemes, application procedures, document requirements, and office locations —
improving public service accessibility.

Signature

Prof. Rupali Padhar

25