LLM-Powered Chatbots: A Practical Guide to User Input Classification and Intent Handling

1. Introduction

If you’ve ever built a chatbot that confidently answered the wrong question, you know the pain of poor intent detection. Imagine a user typing:

“Block my debit card immediately.”

If your chatbot treats that as a generic banking query instead of an urgent fraud request, the experience goes from frustrating to dangerous.

This is where intent classification comes in. Whether you’re building an Dummy Bank banking assistant, a customer service bot, or an internal support tool, correctly classifying user input before handing it off to a Large Language Model (LLM) is key to delivering fast, accurate, and safe responses.

In this guide, we’ll break down how to:

• Detect user intent using three practical approaches — Fine-tuned models, Zero-shot LLMs, and Few-shot LLMs.
• Route each intent to the right handler function for execution.
• Apply these methods to a banking domain example that developers can adapt for their own projects.

2. Chatbot Intent Classification Pipeline

Here’s the high-level workflow you’ll implement:

1. Input Reception – The chatbot receives the raw user message.
2. Preprocessing – Normalize text (lowercasing, punctuation handling, tokenization).
3. Intent Classification – Use ML or LLM to predict the most likely intent (e.g., check_balance, block_card).
4. Handler Mapping – Map the predicted intent to a specific function in your codebase.
5. Response Generation – Call the handler, optionally using an LLM to format or elaborate the output.

Below is a simplified diagram of the pipeline:

By the end of this article, you’ll not only understand the theory but also have ready-to-run code for all three approaches, along with tips for choosing the right one for your use case.

2. Why Intent Classification is Important for Chatbots

Banking customers expect fast and accurate responses. A chatbot without intent classification would behave like a generic Q&A bot—it might give unrelated or vague answers.

With intent classification, the chatbot can:

1. Identify the exact customer need (e.g., “Check account balance”)
2. Route the request to the right handler
3. Provide accurate, domain-specific responses

Example:

• Query: “What’s my savings account balance?”
• Without intent classification → Might return a random banking FAQ answer
• With intent classification → Identifies as “Check_Balance” and fetches live balance

3. Flow of Intent Classification + Handler in LLM-Based Chatbot

Let’s understand the flow of pipeline step by step:

3.1 User Input

Example: “Transfer ₹5000 to my savings account”

What to consider:

• Input may come from different channels: web chat, mobile app, voice → convert ASR result to text for voice.
• Record metadata (user_id, session_id, channel, timestamp) for auditing and debugging.

Following is the example message envelope (JSON):

{
  "user_id": "user-123",
  "session_id": "sess-456",
  "channel": "mobile",
  "text": "Transfer ₹5000 to my savings account",
  "timestamp": "2025-08-12T09:10:00+05:30"
}

3.2 Preprocessing (cleaning & normalization)

Goals: reduce noise, normalize currency/amounts, expand abbreviations, correct obvious typos.

Common steps:

• Trim/normalize whitespace, unicode, punctuation.
• Normalize currency tokens → ₹5000 → numeric 5000.00 plus currency field.
• Mask or redact PII(Personally Identifiable Information) for logs (partial redaction), but keep full data for the handler (in secure memory).
• Language detection / transliteration (if supporting multi-lingual inputs).

Example amount normalization:

def parse_amount(text):
    # very small heuristic example
    match = re.search(r'₹\s?([\d,]+)', text)
    if match:
        return float(match.group(1).replace(',', ''))
    return None

If preprocessing discovers ambiguity (e.g., no amount present), mark for clarification.

3.3 LLM-based Intent Classification

You use an LLM (zero-shot, few-shot, or fine-tuned) to predict intent. Important production details:

• Return both predicted_intent and confidence_score.
• Thresholds: If confidence < threshold (e.g., 0.6), ask a clarifying question or fallback to a smaller model / human.
• Entity hints: LLM can also return entities (amount, target_account, account_type) to speed up pipeline.

Example classifier output:

{
  "predicted_intent": "Fund_Transfer",
  "confidence": 0.92,
  "entities": {
    "amount": 5000.0,
    "currency": "INR",
    "target_account": "savings",
    "recipient_name": null
  }
}

Confidence handling:

if confidence < 0.6:
    ask_clarification("Do you want to transfer money? Please confirm amount and recipient.")

3.4 Intent Validation & Slot / Entity Extraction

Before routing to the handler, validate entities and fill missing slots.

Steps:

• Validate amount > 0 and within user limits.
• Resolve ambiguous targets (“my savings account” → which account id?).
• Extract target account number or nickname from user profile.
• Run fraud checks and quick policy validations (transfer limits, blocked status).

Entity extraction strategy:

• Use combined approach: regex rules for amounts/IFSC, lightweight NER model for names/locations, and LLM for tricky phrasings.

Example check:

if amount > user.available_balance:
    return "Insufficient funds. Your available balance is ₹X."

3.5 Handler Mapping (Router)

Map predicted_intent → handler function. Keep router simple and deterministic.

intent_router = {
  "Check_Balance": handle_check_balance,
  "Fund_Transfer": handle_fund_transfer,
  "Open_Account": handle_open_account,
  "Loan_Enquiry": handle_loan_enquiry,
  "Card_Block": handle_card_block,
  "Branch_Location": handle_branch_location,
}
handler = intent_router[predicted_intent]

Before calling handler, ensure required slots are present. If not, the handler should initiate a slot-filling dialog (ask for missing info).

3.6 Handler Execution (example: handle_fund_transfer)

This is the business logic layer that must be secure, idempotent, auditable, and often synchronous with backend banking APIs.

Key steps inside handle_fund_transfer:

1. Authenticate/authorize user (session token, MFA (Multi-Factor Authentication) status).
2. Validate inputs (amount limits, beneficiary verification).
3. Pre-checks: AML(Anti-Money Laundering)/fraud checks, transaction velocity checks.
4. Confirm: If required, ask the user to confirm (show transfer summary).
5. OTP / 2FA: Request OTP or biometric verification for high-risk transfers.
6. Call core banking API (use idempotency key).
7. Handle API errors (retry/backoff, rollback where applicable).
8. Log & audit: Write transaction record to secure audit trail.
9. Return structured result (success/fail, transaction id, timestamp).

Simplified handler:

def handle_fund_transfer(user_id, amount, target_account):
    # 1. Auth check
    if not is_user_authenticated(user_id):
        return require_login()

    # 2. Validate amount and beneficiary
    if amount <= 0 or amount > get_transfer_limit(user_id):
        return "Transfer amount invalid or exceeds limit."

    # 3. Sufficient balance
    if amount > get_available_balance(user_id):
        return "Insufficient funds."

    # 4. Confirmation & OTP flow
    confirmation = ask_user_confirmation(amount, target_account)
    if not confirmation:
        return "Transfer cancelled."

    if requires_otp(amount):
        otp_ok = verify_otp(user_id)
        if not otp_ok:
            return "OTP validation failed."

    # 5. Call bank API with idempotency_key
    tx = call_core_banking_transfer(user_id, amount, target_account, idempotency_key=uuid4())
    if tx.success:
        audit_log("transfer", user_id, amount, target_account, tx.id)
        return f"₹{amount} transferred successfully. Transaction ID: {tx.id}"
    else:
        handle_failure(tx)
        return "Transfer failed. Please try again or contact support."

Idempotency: always pass unique idempotency keys to avoid duplicate transfers on retries.

3.7 Response Generation

The handler returns a structured response. The response generator formats it for the user, optionally uses LLM to produce friendly wording.

Example final message:

• "₹5000 transferred successfully to your savings account. Transaction ID TXN12345. Would you like a receipt via SMS?"

Make sure the message:

• Avoids leaking sensitive data (full account numbers).
• Provides transaction reference and next steps.

3.8 Auditing, Logging & Compliance

Banking requires strict logs and retention policies.

• Log: user_id, session_id, intent, entities (redacted in logs), handler invoked, API responses, timestamps, geolocation if relevant.
• Audit trail must be tamper-resistant (write-once logs or append-only store).
• GDPR/RBI compliance: minimize PII storage; use encryption-at-rest & in-transit.

Audit record example:

{
  "event":"fund_transfer",
  "user_id":"user-123",
  "amount":5000,
  "target":"savings",
  "tx_id":"TXN12345",
  "timestamp":"2025-08-12T09:10:15+05:30"
}

3.9 Error Handling & Fallbacks

• Low classifier confidence → ask clarifying question or route to human agent.
• API failures → retry with exponential backoff, provide user-friendly error, log incident.
• Security checks fail → escalate to fraud queue, block transaction if necessary.
• Unrecognized intent → route to fallback intent or handover to live agent.

3.10 Monitoring & Metrics

Track these to measure health and improve models:

• Intent classification accuracy, confusion matrix
• Avg pipeline latency (preprocessing → final response)
• Handler success rate (e.g., transfer success %)
• Human-handover rate
• False positives for high-risk intents

Use these logs to improve training data and to retrain periodically.

3.12 Security & Privacy Checklist (banking)

• Enforce strong authentication (session tokens, MFA) before sensitive handlers.
• Mask or avoid logging full account numbers/PINs.
• Use secure channels & encryption for all backend calls.
• Implement rate limits & anomaly detection to prevent abuse.

3.11 Continuous Learning & Retraining

• Capture misclassifications and ambiguous interactions; add them to a labeled dataset.
• Schedule periodic retraining for the fine-tuned model or update few-shot examples for LLM prompts.
• A/B test classifier changes in a staging environment before rolling to production.

3.12 Security & Privacy Checklist (banking)

• Enforce strong authentication (session tokens, MFA) before sensitive handlers.
• Mask or avoid logging full account numbers/PINs.
• Use secure channels & encryption for all backend calls.
• Implement rate limits & anomaly detection to prevent abuse.

3.13 Quick end-to-end example (summary)

1. User: "Transfer ₹5000 to my savings account"
2. Preprocess → extract amount=5000, target=savings
3. LLM classifier → Fund_Transfer (confidence 0.93)
4. Router → handle_fund_transfer()
5. Handler validates, asks OTP, calls bank API with idempotency key
6. Response → "₹5000 transferred successfully. TXN12345."
7. Audit log written and user notified

4. Banking Intent Dataset Example

To train or evaluate an intent classification system for a banking chatbot, you will need a well-structured dataset that captures the variety of ways users might express their requests. Below is a sample dataset for training/testing your banking chatbot intent classifier.

5. Intent Handlers for Banking Chatbot

Once an intent is correctly identified by the classifier, the chatbot needs to decide what to do next. This is where intent handlers come into play. An intent handler is a function or module responsible for executing the specific action linked to an intent. In a banking chatbot, each intent can have a dedicated handler that connects to backend services (like Dummy Bank’s core banking system), retrieves or updates data, and formats the response for the user.

Example handlers:

• handle_check_balance() – Connects to the user’s account system, fetches the latest balance, and presents it in a friendly message.
• handle_fund_transfer() – Validates account details, initiates the transfer, confirms the transaction status, and logs it for auditing.
• handle_open_account() – Guides the user through the required KYC steps, generates a reference number, and schedules a branch visit if needed.
• handle_loan_enquiry() – Checks loan eligibility, fetches applicable loan rates, and provides repayment schedules.
• handle_card_block() – Immediately blocks the reported card, sends confirmation via SMS/email, and prompts the user for reissue options.
• handle_branch_location() – Uses a geolocation API to find the nearest branch or ATM based on the user’s location.

In well-structured chatbots, these handlers are modular and reusable. They can also be enriched with context awareness (e.g., remembering the user’s last transaction) and security layers (e.g., OTP verification before fund transfer). This separation of intent detection and intent handling ensures that the chatbot remains scalable, secure, and easy to maintain.

Following is the sample simulated code above mentioned handlers:

def handle_check_balance(user_id):
    # Simulated balance fetch
    return f"Your account balance is ₹25,340."

def handle_fund_transfer(user_id, amount, target_account):
    # Simulated transfer
    return f"₹{amount} has been transferred to account {target_account}."

def handle_open_account():
    return "To open a savings account, please visit your nearest Dummy Bank branch or apply online at dummy.bank.co.in."

def handle_loan_enquiry(loan_type="home"):
    return f"The current {loan_type} loan interest rate is 8.25% p.a. You can apply via the Dummy Bank website."

def handle_card_block(card_type="debit"):
    return f"Your {card_type} card has been blocked. A replacement will be sent to your registered address."

def handle_branch_location(pincode):
    return f"The nearest Dummy Bank branch to pincode {pincode} is at Main Market Road, Sector 15."

6. Training the Intent Classifier

Training an intent classifier involves teaching a model to correctly identify a user’s goal from their query. This process starts with collecting representative training data for each intent category, followed by preprocessing the text for tokenization. The model is then trained on these labeled examples, learning patterns and keywords associated with each intent. Once trained, the classifier can quickly and accurately predict intents for new, unseen queries, enabling downstream applications like chatbots and virtual assistants to respond appropriately. Regular retraining with fresh data helps maintain accuracy as user behavior and language evolve.

6.1 Fine-tune a smaller model like distilbert-base-uncased for intent classification

Fine-tuning a lightweight model such as distilbert-base-uncased is an efficient way to build a high-performance intent classifier without the computational overhead of large LLMs. DistilBERT retains much of BERT’s language understanding capability while being faster and more resource-friendly, making it ideal for deployment in production environments with limited hardware. By training it on domain-specific data—such as banking-related queries for Dummy Bank—it can achieve high accuracy in recognizing intents like Check_Balance, Fund_Transfer, or Card_Block. This approach combines speed, cost-effectiveness, and adaptability.

Example code:

import pandas as pd
from sklearn.model_selection import train_test_split
from datasets import Dataset
from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification, Trainer, TrainingArguments
import torch

# ---------------------------
# 1. Example Dataset
# ---------------------------
data = [
    # Check_Balance
    ("What is my current account balance?", "Check_Balance"),
    ("Show me my savings balance", "Check_Balance"),
    ("How much money is in my account?", "Check_Balance"),

    # Fund_Transfer
    ("Transfer ₹5000 to my brother's account", "Fund_Transfer"),
    ("Send 2000 rupees to account 1234567890", "Fund_Transfer"),
    ("Make a payment to Ramesh", "Fund_Transfer"),

    # Open_Account
    ("I want to open a new savings account", "Open_Account"),
    ("How can I open a current account?", "Open_Account"),
    ("Open an account for me", "Open_Account"),

    # Loan_Enquiry
    ("Tell me about home loan interest rates", "Loan_Enquiry"),
    ("What is the EMI for a 5 lakh personal loan?", "Loan_Enquiry"),
    ("How can I apply for a car loan?", "Loan_Enquiry"),

    # Card_Block
    ("Block my debit card immediately", "Card_Block"),
    ("I lost my credit card, please block it", "Card_Block"),
    ("Block my ATM card", "Card_Block"),

    # Branch_Location
    ("Where is the nearest Dummy Bank branch?", "Branch_Location"),
    ("Find me a branch near Andheri", "Branch_Location"),
    ("Locate the closest ATM", "Branch_Location"),
]

df = pd.DataFrame(data, columns=["text", "label"])

# ---------------------------
# 2. Encode Labels
# ---------------------------
label_list = df["label"].unique().tolist()
label2id = {label: idx for idx, label in enumerate(label_list)}
id2label = {idx: label for label, idx in label2id.items()}

df["label_id"] = df["label"].map(label2id)

# ---------------------------
# 3. Train-Test Split
# ---------------------------
train_texts, val_texts, train_labels, val_labels = train_test_split(
    df["text"], df["label_id"], test_size=0.2, random_state=42
)

train_df = pd.DataFrame({"text": train_texts, "label": train_labels})
val_df = pd.DataFrame({"text": val_texts, "label": val_labels})

# ---------------------------
# 4. Convert to Hugging Face Dataset
# ---------------------------
train_dataset = Dataset.from_pandas(train_df)
val_dataset = Dataset.from_pandas(val_df)

# ---------------------------
# 5. Tokenization
# ---------------------------
tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert-base-uncased")

def tokenize(batch):
    return tokenizer(batch["text"], padding=True, truncation=True, max_length=64)

train_dataset = train_dataset.map(tokenize, batched=True)
val_dataset = val_dataset.map(tokenize, batched=True)

# ---------------------------
# 6. Load Model
# ---------------------------
model = DistilBertForSequenceClassification.from_pretrained(
    "distilbert-base-uncased",
    num_labels=len(label_list),
    id2label=id2label,
    label2id=label2id
)

# ---------------------------
# 7. Training Arguments
# ---------------------------
training_args = TrainingArguments(
    output_dir="./intent_classifier_model",
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=5e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=5,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
    load_best_model_at_end=True
)

# ---------------------------
# 8. Trainer
# ---------------------------
def compute_metrics(eval_pred):
    from sklearn.metrics import accuracy_score, f1_score
    logits, labels = eval_pred
    preds = logits.argmax(axis=-1)
    return {
        "accuracy": accuracy_score(labels, preds),
        "f1": f1_score(labels, preds, average="weighted")
    }

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics
)

# ---------------------------
# 9. Train
# ---------------------------
trainer.train()

# ---------------------------
# 10. Test Prediction
# ---------------------------
test_queries = [
    "Please transfer 1000 rupees to my son's account",
    "Find me the nearest dummy bank branch in Pune",
    "I lost my ATM card",
    "Show me my account balance"
]

tokens = tokenizer(test_queries, padding=True, truncation=True, return_tensors="pt")
outputs = model(**tokens)
predictions = torch.argmax(outputs.logits, dim=-1)

for query, pred_id in zip(test_queries, predictions):
    print(f"Query: {query} -> Intent: {id2label[pred_id.item()]}")

Expected output:

Query: Please transfer 1000 rupees to my son's account -> Intent: Fund_Transfer
Query: Find me the nearest Dummy bank branch in Pune -> Intent: Branch_Location
Query: I lost my ATM card -> Intent: Card_Block
Query: Show me my account balance -> Intent: Check_Balance

6.2 LLM-based Intent Classification (Zero-shot classification) using Hugging Face pipeline

Zero-shot intent classification leverages the language understanding power of large language models to identify user intents without any task-specific training data. Using Hugging Face’s pipeline API, we can provide the model with a query and a list of possible intent labels, and it will determine the most likely match based on its vast pre-trained knowledge. This approach is especially useful for quickly deploying chatbots in domains like banking, where intents (e.g., Check_Balance, Fund_Transfer, Card_Block) can be recognized instantly, even if no historical data is available for those categories.

Example Code:

from transformers import pipeline

# Banking intents
intents = [
    "Check_Balance",
    "Fund_Transfer",
    "Open_Account",
    "Loan_Enquiry",
    "Card_Block",
    "Branch_Location"
]

classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")

query = "Transfer ₹5000 to my savings account"
result = classifier(query, candidate_labels=intents)

predicted_intent = result['labels'][0]
print("Predicted Intent:", predicted_intent)

Sample Output

Predicted Intent: Fund_Transfer

6.3 LLM-based Intent Classification (Few-shot classification) using Hugging Face pipeline

Few-shot classification leverages the power of Large Language Models to accurately predict intents with only a handful of labeled examples per category. Instead of training a model from scratch, we simply provide the LLM with sample queries for each intent along with the user’s new query. Using the Hugging Face pipeline, the LLM applies its vast language understanding to match the query to the closest intent, even if the wording is unfamiliar. This approach is fast to implement, requires minimal data, and works particularly well for domains like banking where intent categories are clearly defined.

Example Code:

from transformers import pipeline

# Banking intents
intents = [
    "Check_Balance",
    "Fund_Transfer",
    "Open_Account",
    "Loan_Enquiry",
    "Card_Block",
    "Branch_Location"
]

# Few-shot examples for better classification
examples = [
    ("Show me my account balance", "Check_Balance"),
    ("Please transfer ₹2000 to Ramesh's account", "Fund_Transfer"),
    ("I want to apply for a home loan", "Loan_Enquiry"),
    ("I lost my debit card, please block it", "Card_Block"),
    ("Where is the nearest Dummy bank branch in Delhi?", "Branch_Location"),
]

# Create the few-shot prompt
def build_few_shot_prompt(query):
    prompt = "Classify the following customer queries into one of these intents:\n"
    prompt += ", ".join(intents) + "\n\n"
    prompt += "Examples:\n"
    for ex_query, ex_intent in examples:
        prompt += f"Query: {ex_query}\nIntent: {ex_intent}\n\n"
    prompt += f"Query: {query}\nIntent:"
    return prompt

query = "Transfer ₹5000 to my savings account"
prompt = build_few_shot_prompt(query)

# Using a text-generation pipeline (could be GPT-like model)
generator = pipeline("text-generation", model="meta-llama/Llama-2-7b-chat-hf", device_map="auto")

response = generator(prompt, max_new_tokens=10, temperature=0.0)
predicted_intent = response[0]['generated_text'].split("Intent:")[-1].strip()

print("Predicted Intent:", predicted_intent)

6.4 Comparision of LLM-based Intent Classification (Zero-shot vs. Few-shot classification)

6.5 Comparision of Fine-Tuning a Smaller Model for Intent Classification and LLM-Based Intent Classification

8. Conclusion

In the fast-paced world of digital banking, a chatbot’s ability to accurately identify customer intent is the foundation for delivering seamless, human-like support. Our exploration of intent classification — from fine-tuning smaller models to leveraging powerful LLMs — shows that there’s no one-size-fits-all solution.

Fine-tuned smaller models like DistilBERT excel in speed, cost-efficiency, and privacy, making them a strong choice for banks that deal with fixed sets of intents and require on-premises deployment. LLM-based approaches, on the other hand, offer unmatched flexibility, adaptability to new domains, and zero-shot capabilities — perfect for scenarios where customer queries evolve quickly or domain-specific terms frequently emerge.

Ultimately, the best approach depends on your priorities:

• If cost, privacy, and speed are paramount, go for a fine-tuned smaller model.
• If adaptability, reduced training overhead, and rapid intent expansion are more important, LLM-based classification is the way forward.

By choosing the right intent classification strategy, banks can ensure their chatbots not only respond faster but also understand customers better — building trust, improving satisfaction, and making every digital interaction as smooth as talking to a trusted branch representative.