Chatbot Project in Python With Source Code: Intent Bot Plus LLM Fallback

How to build a chatbot in Python, step by step

1. Step 1. Set up the project

   Create a folder and a virtual environment, then install four packages.

   mkdir college-chatbot && cd college-chatbot
   python -m venv .venv
   # Windows: .venv\Scripts\activate    macOS/Linux: source .venv/bin/activate
   pip install scikit-learn joblib openai streamlit

   Set your API key as an environment variable named OPENAI_API_KEY (or whatever your provider uses). Never paste a key into your code or push it to GitHub. You can build and test the whole first stage without any key at all.

2. Step 2. Write the intents file

   The intents file is your training data and your reply bank in one place. Each intent has a tag, example user phrases (patterns) and approved replies (responses).

   {
     "intents": [
       {"tag": "greeting",
        "patterns": ["hi", "hello", "hey there", "good morning", "namaste", "is anyone there"],
        "responses": ["Hello! Ask me about fees, admissions, timings or placements."]},
       {"tag": "fees",
        "patterns": ["what is the fee", "how much is the btech fee", "fee structure",
                     "hostel fees", "can i pay fees in instalments", "fees kitna hai"],
        "responses": ["The fee structure is on the college website under Admissions, then Fees."]},
       {"tag": "admissions",
        "patterns": ["how do i apply", "admission process", "last date to apply",
                     "documents needed for admission", "is there an entrance exam"],
        "responses": ["Applications open on the college portal. Keep your marksheets and ID ready."]},
       {"tag": "timings",
        "patterns": ["what are the college timings", "when does college start",
                     "library timings", "is college open on saturday", "office hours"],
        "responses": ["Classes run 9 am to 4 pm, Monday to Friday. The office closes at 5 pm."]},
       {"tag": "goodbye",
        "patterns": ["bye", "thanks", "thank you", "see you", "that is all"],
        "responses": ["Glad to help. All the best!"]}
     ]
   }

   Save it as intents.json. Add a placements intent the same way. Aim for 6 to 10 varied patterns per intent, including the short, misspelled and Hinglish ways real students type. Variety in patterns matters far more than the number of intents.

3. Step 3. Train the intent classifier with scikit-learn

   A scikit-learn pipeline chains the vectorizer and the classifier so you can save and load them as one object.

   # train.py
   import json
   import joblib
   from sklearn.pipeline import make_pipeline
   from sklearn.feature_extraction.text import TfidfVectorizer
   from sklearn.linear_model import LogisticRegression
   
   with open("intents.json", encoding="utf-8") as f:
       data = json.load(f)
   
   X, y = [], []
   for intent in data["intents"]:
       for pattern in intent["patterns"]:
           X.append(pattern.lower())
           y.append(intent["tag"])
   
   model = make_pipeline(
       TfidfVectorizer(analyzer="char_wb", ngram_range=(2, 4)),
       LogisticRegression(max_iter=1000, C=10),
   )
   model.fit(X, y)
   joblib.dump(model, "intent_model.joblib")
   print(f"Trained on {len(X)} phrases across {len(set(y))} intents")

   Two choices worth explaining. Character n-grams (analyzer="char_wb") match pieces of words, so "admision" and "admission" still look similar, which helps with typos and mixed spellings. A higher C value makes the classifier more confident on a tiny dataset, which keeps the threshold in Step 4 meaningful. Run python train.py whenever you edit intents.json.

4. Step 4. Predict the intent and route by confidence

   The bot asks the model for probabilities, not just a label, so it knows when it is unsure.

   # bot.py
   import json
   import random
   import joblib
   
   model = joblib.load("intent_model.joblib")
   with open("intents.json", encoding="utf-8") as f:
       RESPONSES = {i["tag"]: i["responses"] for i in json.load(f)["intents"]}
   
   THRESHOLD = 0.5
   
   def classify(text):
       probs = model.predict_proba([text.lower().strip()])[0]
       best = probs.argmax()
       return model.classes_[best], float(probs[best])
   
   def reply(text, history):
       tag, confidence = classify(text)
       if confidence >= THRESHOLD:
           return random.choice(RESPONSES[tag]), f"intent: {tag} ({confidence:.2f})"
       return llm_fallback(text, history), f"llm (best guess {tag}, {confidence:.2f})"

   The reply function returns the route as well as the answer. Showing "intent: fees (0.83)" next to each reply during testing tells you instantly whether the classifier or the LLM answered, and why.

5. Step 5. Add the LLM fallback

   Add this to bot.py. The system prompt keeps the LLM in role and, just as important, stops it from inventing college-specific facts it was never given.

   import os
   from openai import OpenAI
   
   client = OpenAI()  # reads OPENAI_API_KEY from the environment
   MODEL = os.environ.get("LLM_MODEL", "gpt-4o-mini")  # use any current chat model from your provider's docs
   SYSTEM = (
       "You are the helpdesk assistant for a college in India. Reply in two or three "
       "short sentences. If asked about specific fees, dates, cut-offs or rules, "
       "say you do not have that information and suggest contacting the college office."
   )
   
   def llm_fallback(text, history):
       messages = [{"role": "system", "content": SYSTEM}]
       messages += history[-6:]  # last three turns for context
       messages.append({"role": "user", "content": text})
       try:
           out = client.chat.completions.create(
               model=MODEL, messages=messages, temperature=0.3
           )
           return out.choices[0].message.content
       except Exception as err:
           return f"Sorry, I could not reach the AI service ({type(err).__name__})."

   Passing the last few turns of history lets the bot handle follow-ups like "and for MBA?". A low temperature keeps replies short and steady. The instruction about fees and dates is your defence against AI hallucination: an LLM will happily make up a fee amount if you let it.

6. Step 6. Chat in the terminal

   A terminal loop is the fastest way to test. Keep it as a separate file so the bot logic stays reusable.

   # chat.py
   from bot import reply
   
   history = []
   print("College helpdesk bot. Type 'quit' to exit.")
   while True:
       text = input("You: ").strip()
       if not text:
           continue
       if text.lower() in {"quit", "exit"}:
           print("Bot: Goodbye!")
           break
       answer, route = reply(text, history)
       print(f"Bot: {answer}   [{route}]")
       history += [
           {"role": "user", "content": text},
           {"role": "assistant", "content": answer},
       ]

   Run python chat.py and try "fees kitna hai", "hostel fess" (with the typo) and "can you explain recursion". The first two should hit the fees intent; the third should route to the LLM.

7. Step 7. Build the Streamlit chat interface

   Streamlit has chat elements built in, so a browser UI takes about 20 lines. Session state keeps the conversation across reruns.

   # app.py
   import streamlit as st
   from bot import reply
   
   st.title("College Helpdesk Bot")
   
   if "history" not in st.session_state:
       st.session_state.history = []
   
   for msg in st.session_state.history:
       st.chat_message(msg["role"]).write(msg["content"])
   
   if text := st.chat_input("Ask about fees, admissions, timings..."):
       st.chat_message("user").write(text)
       answer, route = reply(text, st.session_state.history)
       with st.chat_message("assistant"):
           st.write(answer)
           st.caption(f"Answered by {route}")
       st.session_state.history += [
           {"role": "user", "content": text},
           {"role": "assistant", "content": answer},
       ]

   Run it with streamlit run app.py. The caption under each reply makes your demo far more convincing, because the examiner can see the routing decision happen live.

8. Step 8. Evaluate the classifier and tune the threshold

   Ask a friend to write 30 test questions you have never seen: 20 that belong to your intents and 10 that do not (general questions the LLM should get). Then measure.

   # evaluate.py
   import joblib
   from sklearn.metrics import classification_report
   
   model = joblib.load("intent_model.joblib")
   in_scope = [("btech fee kitni hai", "fees"), ("when is the last date to apply", "admissions"),
               ("library open on sunday?", "timings"), ("hello", "greeting")]  # add your 20
   out_of_scope = ["what is machine learning", "write a poem about rain"]  # add your 10
   
   texts, labels = zip(*in_scope)
   print(classification_report(labels, model.predict(list(texts)), zero_division=0))
   
   for t in [0.3, 0.4, 0.5, 0.6, 0.7]:
       kept = sum(model.predict_proba([q])[0].max() >= t for q in texts)
       leaked = sum(model.predict_proba([q])[0].max() >= t for q in out_of_scope)
       print(f"threshold {t}: in-scope answered {kept}/{len(texts)}, "
             f"out-of-scope wrongly answered {leaked}/{len(out_of_scope)}")

   Pick the threshold where in-scope coverage is high and out-of-scope leaks are near zero. Put that table in your report. If a specific intent scores poorly, add more varied patterns to it rather than more intents.

Frequently asked questions

Keep learning

References

• scikit-learn: TfidfVectorizer documentation
• scikit-learn: LogisticRegression documentation
• OpenAI Python SDK (official GitHub)
• Streamlit documentation: build a basic LLM chat app