DEV Community: Hafsa Noor Muhammad

Bug Smash: Fixing 5 Critical Bugs in My Django-Groq AI Chatbot

Hafsa Noor Muhammad — Thu, 23 Jul 2026 14:30:44 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

Project Overview

I built a Legal & Wellness AI Chatbot using Django and Groq API (Llama 3.3-70B). The app helps users get information about legal topics and wellness tips with mode switching, PDF document analysis, chat history export, Sentry error monitoring, and Google Gemini AI for sentiment analysis.

Bug Fix or Performance Improvement

I fixed 5 critical bugs in my codebase covering security, logic, performance, and reliability issues.

Code

Bug 1: Duplicate SECRET_KEY (Security)

File: chatbot_project/settings.py

Before:

SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'fallback-key')
# ... some lines ...
SECRET_KEY = 'hardcoded-key'  # ❌ DUPLICATE!
DEBUG = True  # ❌ HARDCODED!

After:

SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'fallback-key')
DEBUG = os.environ.get('DEBUG', 'False') == 'True'

Bug 2: Mode Enforcement Bypass (Logic)

File: chatbot/utils.py

Before:

def generate_response(user_input, mode="legal", chat_history=None):
    detected_domain = detect_domain(user_input)
    # ❌ API call happens even if mode is wrong
    response = client.chat.completions.create(...)
    return response

After:

def generate_response(user_input, mode="legal", chat_history=None):
    detected_domain = detect_domain(user_input)

    if mode == "legal" and detected_domain == "wellness":
        return "🌿 I'm in Legal Mode. Please switch to Wellness Mode."

    if mode == "wellness" and detected_domain == "legal":
        return "⚖️ I'm in Wellness Mode. Please switch to Legal Mode."

    if detected_domain == "unknown":
        return "🤔 I'm not sure. Could you please clarify?"

    # ✅ API call only if domain matches mode
    response = client.chat.completions.create(...)
    return response

Screenshots:

Legal Mode rejecting wellness question:

Wellness Mode rejecting legal question:

Bug 3: Session Memory Leak (Performance)

File: chatbot/views.py

Before:

chat_sessions = {}  # ❌ Never cleans up!

def chat(request):
    if session_id not in chat_sessions:
        chat_sessions[session_id] = {'history': [], 'mode': mode}
    # ❌ No expiry, no limit!

After:

import time

def cleanup_old_sessions():
    current_time = time.time()

    # Remove sessions older than 1 hour
    expired_sessions = [
        sid for sid, session in chat_sessions.items()
        if current_time - session.get('last_accessed', 0) > 3600
    ]
    for sid in expired_sessions:
        del chat_sessions[sid]

    # Limit to 100 sessions
    if len(chat_sessions) > 100:
        oldest_key = min(chat_sessions.keys(),
                         key=lambda k: chat_sessions[k].get('last_accessed', 0))
        del chat_sessions[oldest_key]

def chat(request):
    cleanup_old_sessions()

    if session_id not in chat_sessions:
        chat_sessions[session_id] = {
            'history': [],
            'mode': mode,
            'last_accessed': time.time()
        }

    session['last_accessed'] = time.time()

Bug 4: PDF Emoji Export Bug (Reliability)

File: chatbot/views.py

Before:

def remove_emojis(text):
    emoji_pattern = re.compile(
        "["
        u"\U0001F600-\U0001F64F"  # emoticons
        u"\U0001F300-\U0001F5FF"  # symbols & pictographs
        # ❌ Missing many emoji ranges
        "]+",
        flags=re.UNICODE
    )
    return emoji_pattern.sub(r'', text).strip()

After:

def remove_emojis(text):
    emoji_pattern = re.compile(
        "["
        u"\U0001F600-\U0001F64F"  # emoticons
        u"\U0001F300-\U0001F5FF"  # symbols & pictographs
        u"\U0001F680-\U0001F6FF"  # transport & map symbols
        u"\U0001F1E0-\U0001F1FF"  # flags
        u"\U00002702-\U000027B0"  # dingbats
        u"\U000024C2-\U0001F251"  # enclosed characters
        u"\U0001F900-\U0001F9FF"  # supplemental symbols
        u"\U0001FA70-\U0001FAFF"  # symbols extended-a
        u"\U00002600-\U000026FF"   # ✅ NEW: misc symbols
        u"\U00002B50-\U00002BFF"   # ✅ NEW: star/arrows
        u"\U000000A9-\U000000AE"   # ✅ NEW: copyright/trademark
        "]+",
        flags=re.UNICODE
    )

    # Handle common problematic characters
    text = text.replace('•', '-')
    text = text.replace('★', '*')
    text = text.replace('☆', '*')
    text = text.replace('→', '->')
    text = text.replace('…', '...')

    return emoji_pattern.sub(r'', text).strip()

Bug 5: Duplicate PDF Extraction (Performance)

File: chatbot/views.py

Before:

def upload_and_analyze_pdf(request):
    # ❌ EXTRACTION #1: Direct extraction
    pdf_reader = PyPDF2.PdfReader(pdf_file)
    text = ""
    for page in pdf_reader.pages:
        text += page.extract_text() + "\n"

After:

def upload_and_analyze_pdf(request):
    # ✅ Single extraction using helper function
    text = extract_text_from_pdf(pdf_file)

    if not text:
        return JsonResponse({'error': 'Could not extract text from PDF.'}, status=400)

My Improvements

Technical Approach:

Security: Replaced hardcoded SECRET_KEY with environment variable, added fallback for development
Logic: Added early returns for mode mismatches to prevent unnecessary API calls and save costs
Performance: Implemented session cleanup with 1-hour expiry, 100-session limit, and 20-message history
Reliability: Expanded emoji regex pattern to cover all emoji ranges and added special character handling
Code Quality: Replaced duplicate PDF extraction with reusable helper function

Impact:

SECRET_KEY now secure and production-ready
No wasted API calls when modes mismatch
Memory usage bounded and stable
PDF export works 100% with all messages
CPU usage reduced for PDF processing

Best Use of Sentry

I integrated Sentry to catch errors in real-time using Error Monitoring.

Sentry Middleware:

class SentryErrorMiddleware:
    def process_exception(self, request, exception):
        sentry_sdk.capture_exception(exception)
        sentry_sdk.set_context("request_details", {
            "method": request.method,
            "path": request.path,
            "user": str(request.user) if request.user.is_authenticated else "Anonymous",
        })
        return None

Sentry Configuration:

import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration

sentry_sdk.init(
    dsn=os.environ.get("SENTRY_DSN"),
    integrations=[DjangoIntegration()],
    traces_sample_rate=1.0,
    send_default_pii=True,
)

Sentry in Action:
When I triggered a test error, Sentry immediately caught it:

What Sentry showed me:

Error Type: ZeroDivisionError
File: views.py
Time: 10 minutes ago

Best Use of Google AI

I used Google Gemini AI to replace the placeholder sentiment analysis.

Before (Placeholder):

def get_sentiment(text):
    return "NEUTRAL", 0.5  # ❌ Always neutral!

After (Gemini AI):

import google.genai as genai

def get_sentiment_with_gemini(text):
    client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
    response = client.models.generate_content(
        model="gemini-1.5-flash",
        contents=f"Analyze sentiment: '{text}'. Return POSITIVE, NEGATIVE, or NEUTRAL"
    )
    return response.text.strip()

def get_sentiment(text):
    if genai_client:
        return get_sentiment_with_gemini(text)
    return "NEUTRAL", 0.5

Impact:

Accurate sentiment analysis instead of always returning NEUTRAL
Better user experience with fallback to neutral if Gemini fails

View all changes on GitHub

I Built a Legal & Wellness AI Assistant with Django + Groq (Llama 3.3) — Here's How

Hafsa Noor Muhammad — Mon, 13 Jul 2026 10:41:13 +0000

Introduction

A few weeks ago, I started building something I had been thinking about for a while. Legal advice is expensive, and mental wellness resources aren't always easy to access. I wondered if I could combine both in one tool.

So I built a dual-mode AI assistant. One mode handles legal questions like contracts and intellectual property. The other mode focuses on wellness topics like stress and anxiety.

It is not a replacement for professionals. But it can be a helpful starting point for people who need basic information.

What It Does

The assistant has two modes.

Legal mode answers questions about contracts, intellectual property, court procedures, and laws. It explains things in simple language and always reminds users to consult a lawyer.

Wellness mode offers guidance on stress, anxiety, sleep, motivation, and mental health. It provides practical tips and encourages users to seek professional help when needed.

Users can switch between modes with one click. The bot also detects if a question matches the current mode and suggests switching if it does not.

The Tech Stack

I used Django for the web framework. It handles routing, sessions, and the backend logic.

For AI, I used Groq's API with the Llama 3.3 70B model. The responses are fast and accurate.

The frontend is built with HTML, CSS, and JavaScript. It is simple and works well on both desktop and mobile.

For deployment, I used Streamlit. It made the process straightforward.

How I Built It

Let me walk through the key parts of the code.

The first thing I did was define system prompts for each mode. These prompts tell the AI how to behave and what to avoid.

For legal mode, I instructed the AI to only answer legal questions and to always add a disclaimer about consulting a lawyer.

For wellness mode, I focused on empathy and practical advice, with a disclaimer about consulting a healthcare provider.

Then I built a domain detection system. It uses keyword scoring to figure out if a question is legal, wellness, or unknown. If the question does not match the current mode, the bot politely asks the user to switch.

This is how the detection works. I created two lists of keywords. Legal keywords include words like contract, patent, lawsuit, and copyright. Wellness keywords include stress, anxiety, sleep, and meditation. The system compares the scores and decides which domain the question belongs to.

For storing conversations, I used Django sessions. Each user gets their own session, and the bot remembers the last twenty messages. This keeps the context natural without hitting token limits.

Here is how the session storage works. When a user sends a message, the bot checks the session history. It generates a response using the current mode and the conversation context. Then it saves the new message and response to the session. If the history exceeds twenty messages, it keeps only the most recent ones.

The Groq API integration is simple. I send the system prompt, the conversation history, and the user's message. The API returns a response, which I send back to the frontend.

I also added error handling. If something goes wrong, the bot shows a friendly error message instead of breaking.

Challenges I Faced

The hardest part was prompt engineering. I had to test many different prompts to get accurate and safe responses. The tone had to be professional in legal mode and empathetic in wellness mode. Finding the right balance took time.

Domain detection was tricky too. Some words appear in both domains. For example, the word stress can appear in legal contexts like emotional distress. I had to refine the keyword lists to reduce false positives.

Session management was another challenge. Django sessions work well, but they have size limits. Storing too much history could cause problems. I decided to keep only the last twenty messages. This is enough for context and stays within the limits.

Security was important. I used environment variables to store the API key. This keeps it out of the code and safe from accidental exposure.

What I Learned

This project taught me a lot about working with AI APIs. Groq is incredibly fast. Responses come back in under two seconds, which makes the bot feel responsive and natural.

I also learned about prompt engineering. The way you structure a prompt has a huge impact on the quality of the response. Small changes can make a big difference.

Django sessions are simple to use but have limitations. For production, I would consider Redis or a database for better scalability.

Domain detection with keyword scoring works surprisingly well. It is not perfect, but it is good enough for this use case.

Deploying on Streamlit was easy, but session persistence can be tricky. In-memory storage resets when the server restarts. For a production app, I would use a more persistent solution.

What I Plan to Add Next

I have a few features in mind for the future.

I want to add PDF upload so users can upload legal documents for analysis. That would be a useful feature for people reviewing contracts.

User authentication would allow people to save their chat history and access it later.

I also want to add dark mode for better usability at night.

Chat export would let users download their conversations as PDF or text files.

Multi-language support could make the tool accessible to more people.

Voice input is another feature I am considering. It would make the bot easier to use on mobile.

Try It Yourself

You can test the bot with a legal question, like What is intellectual property?, or ask for wellness advice, such as _How can I reduce stress? _To try it for yourself, visit the live demo: https://django-groq-ai-assistant-mdog3pri4eef5lusavapkg.streamlit.app/

Final Thoughts

Building this project was a great learning experience. I started with a simple idea and turned it into something functional and useful.

It is not perfect, and there is always room for improvement. But I am happy with how it turned out.

If you are building something similar, I would love to hear about it. Feel free to share your experience in the comments.

Thank you for reading.

Disclaimer

This tool provides general information only. It is not a substitute for professional legal or medical advice. Always consult a qualified professional for your specific situation.