Crafting Context Aware Chatbots: How I Taught My IT Support Bot to Say “No”

Ever had your carefully crafted chatbot turn into a runaway hit for all the wrong reasons? Picture this: you proudly deploy your cutting-edge AI chatbot at your college, meticulously trained to handle tricky IT support questions. Before you know it, students are lining up—not to reset passwords or troubleshoot Wi-Fi—but to have it write their term papers or wax poetic about the meaning of life. (Because, why study when AI can do it for you?)

Yes, my friends, that happened to me.

Armed with Ollama and Flask, I set out to build a highly efficient chatbot exclusively for IT queries—only to discover that clever students had turned it into their own AI-powered homework wizard. Quickly, I realized that understanding context and intent wasn’t just a feature; it was survival.

AI Gone Rogue: When Context Goes Missing

At first, my chatbot was like that one friend you invite over for pizza and a movie, who then proceeds to rearrange your furniture and give unsolicited life coaching. Here’s the simple yet misguided original code snippet that opened Pandora’s box:

@bp.route('/chat', methods=['POST'])
def chat():
    user_input = request.json.get("prompt", "")
    response = requests.post(OLLAMA_URL, json={
        "model": "llama3.2:1b",
        "prompt": user_input
    })
    return response.json()

Neat, tidy, and entirely too trusting. Within days, students figured out how to coax the bot into crafting five-paragraph essays on existentialism instead of sticking to “Why can’t I print from the lab?”

Laying Down the Law (in Code)

Much like an enthusiastic puppy, our chatbot needed firm boundaries. Just like you wouldn’t trust your golden retriever with an unattended Thanksgiving turkey, I knew I couldn’t trust my chatbot without strict behavioral guardrails.

Step 1: The System Prompt — Your AI’s House Rules

Think of the system prompt as your chatbot’s laminated rulebook:

def sanitize_prompt(user_input: str) -> str:
    system_prompt = (
        "You are RadicalIT Support Assistant. You ONLY handle IT support questions."
        " Politely refuse non-IT related queries, especially homework requests."

        "nnUser question: "
    )
    return f"{system_prompt}{user_input}nnResponse:"

Now, instead of wandering off into literature class, our bot knew to respond like a well-trained bouncer: “Sorry, you’re cool—but this ID is fake.”

Step 2: Keyword Filtering — The Last Line of Defense

Because students are a lot like well, students, constantly testing the limits, we added keyword-based filtering as the final defense layer:

FORBIDDEN_KEYWORDS = ["essay", "homework", "write my assignment", "thesis"]

def contains_forbidden_content(user_input):
    return any(keyword in user_input.lower() for keyword in FORBIDDEN_KEYWORDS)

### If the chatbot detects academic desperation, 
### it gently, yet firmly, pushed back:

if contains_forbidden_content(user_input):
    return jsonify({"response": "Nice try! My powers are mighty but strictly limited to IT support. Maybe the library can help?"})

Trust, but Verify: Logging the Good, the Bad, and the Shakespearean

Logs aren’t just IT dogma; they’re the forensic breadcrumbs of chatbot behavior:

def log_chat_interaction(user_input, response, was_filtered=False):
    logger.info(f"User asked: {user_input[:100]}...")
    logger.info(f"Bot responded: {response[:100]}...")
    logger.info(f"Filtered request: {was_filtered}")

Every request and response got logged, letting us track if the chatbot stayed true to its IT-only creed or tried to moonlight as a literature professor.

Front-End Grace Under Pressure

A solid backend deserves a smooth, responsive frontend. Our JavaScript took care of that with a little humor and grace:

const CHAT_API_URL = "/api/chat";

async function sendMessage(message) {
    const res = await fetch(CHAT_API_URL, {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({ message })
    });
    const data = await res.json();
    if (data.error) {
        displayMessage("Bot", "Oops! Something went sideways.");
    } else {
        displayMessage("Bot", data.response);
    }
}

It wasn’t just about answering questions—it was about doing so without losing its cool.

Best Practices for Crafting Context-Aware Chatbots

Through trial, error, and more than a few double facepalms, here’s what I’ve learned:

Define Clear Boundaries: Chatbots need explicit instructions to avoid becoming digital chaos agents.
Context Is Everything: Keyword filters are a safety net, but contextual prompts are the first line of defense.
Polite Humor Is Your Friend: A gentle joke diffuses frustration and keeps users coming back.
Log Everything: What gets logged, gets improved. No logs? No lessons.

AGI Dreams, Real-World Realities

Sure, we can fantasize about Artificial General Intelligence—an AI that understands every nuance and subtext of human conversation. But until that day comes, reality (and good coding discipline) will keep our chatbots in check.

Because let’s face it: the world doesn’t need another chatbot quoting Hamlet. Students already have caffeine-fueled midnight cramming sessions for that. What we needed—and built—was an IT assistant that can say: “To be or not to be? Not my department. Go reset your password.”

Stay curious, stay mischievous, and keep those chatbots focused.

Got your own quirky AI stories? Drop a comment below and let’s swap war stories!