(Part -1)
I built a customer support chatbot that can answer user queries and track orders using Mistral 7B, SQLite, and Docker. This chatbot is integrated with Ollama to generate intelligent responses and can retrieve real-time order statuses from a database. The project is fully containerized using Docker and version-controlled with GitHub.
In Part 1, we cover:
✅ Setting up Mistral 7B with Ollama (Dockerized Version)
✅ Connecting the chatbot to SQLite for order tracking
✅ Running everything inside Docker
✅ Pushing the project to GitHub
In Part 2, we will expand the chatbot by:
🚀 Turning it into an API with FastAPI
🎨 Building a Web UI using Streamlit
💾 Allowing users to add new orders dynamically
📂 Project Structure
Here’s the structure of the project:
llm-chatbot/
├── Dockerfile # Docker setup for chatbot
├── setup_db.py # Initializes the SQLite database
├── chatbot.py # Main chatbot Python script
├── requirements.txt # Python dependencies
├── orders.db # SQLite Database (created dynamically, not tracked in Git)
└── README.md # Documentation
✅ The database (orders.db) is dynamically created and not committed to Git to keep things clean.
🚀 Tech Stack
🔧 Step 1: Setting Up Mistral 7B With Ollama (Dockerized Version)
To generate human-like responses, we use Mistral 7B, an open-source LLM that runs efficiently on local machines. Instead of installing Ollama directly, we use its Dockerized version.
📌 Install Ollama (Docker Version)
Run the following command to pull and start Ollama as a Docker container:
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
-d→ Runs Ollama in the background-v ollama:/root/.ollama→ Saves model files persistently-p 11434:11434→ Exposes Ollama’s API on port 11434--name ollama→ Names the container “ollama”
📌 Download Mistral 7B
Once Ollama is running in Docker, download Mistral 7B by running:
docker exec -it ollama ollama pull mistral
✅ Now we have Mistral 7B running inside Docker! 🎉
📦 Step 2: Creating the Chatbot
📌 chatbot.py (Main Chatbot Code)
This Python script:
✅ Takes user input
✅ Checks if it’s an order query
✅ Fetches order status from SQLite (if needed)
✅ If not an order query, sends it to Mistral 7B
import requests
import sqlite3
import os
# Ollama API endpoint
url = "http://localhost:11434/api/generate"
# Explicitly set the correct database path inside Docker
DB_PATH = "/app/orders.db"
# Function to fetch order status from SQLite
def get_order_status(order_id):
# Ensure the database file exists before trying to connect
if not os.path.exists(DB_PATH):
return "Error: Database file not found! Please ensure the database is initialized."
conn = sqlite3.connect(DB_PATH)
cursor = conn.cursor()
# Check if the orders table exists
cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='orders';")
table_exists = cursor.fetchone()
if not table_exists:
conn.close()
return "Error: Orders table does not exist!"
cursor.execute("SELECT status FROM orders WHERE order_id = ?", (order_id,))
result = cursor.fetchone()
conn.close()
return result[0] if result else "Sorry, I couldn't find that order."
# System instruction for chatbot
system_prompt = """
You are a customer support assistant for an online shopping company.
Your job is to help customers with order tracking, returns, and product details.
Always be polite and provide helpful answers.
If the user asks about an order, ask them for their order number.
"""
print("Welcome to the Customer Support Chatbot! Type 'exit' to stop.\n")
while True:
user_input = input("You: ")
if user_input.lower() == "exit":
print("Goodbye! 👋")
break
# Check if the user provided an order number (5-digit number)
words = user_input.split()
order_id = next((word for word in words if word.isdigit() and len(word) == 5), None)
if order_id:
chatbot_response = f"Order {order_id} Status: {get_order_status(order_id)}"
else:
# Send the question to Mistral for a response
data = {
"model": "mistral",
"prompt": f"{system_prompt}\nCustomer: {user_input}\nAgent:",
"stream": False
}
response = requests.post(url, json=data)
chatbot_response = response.json()["response"]
print("Chatbot:", chatbot_response)
✅ Now the chatbot can track orders and answer general questions!
🐳 Step 2: Running Everything with Docker & Docker Compose
To make deployment easier, we containerized the chatbot using Docker Compose, which allows us to manage multiple services (chatbot & database) easily.
📌 docker-compose.yml (Manages Services)
version: '3.8'
services:
chatbot:
build: .
container_name: chatbot_container
volumes:
- chatbot_data:/app
stdin_open: true
tty: true
command: >
sh -c "python setup_db.py && python chatbot.py"
volumes:
chatbot_data:
✅ What This Does:
- Defines the chatbot service (
chatbot_container) - Mounts a volume to persist database files
- Automatically runs
setup_db.pybefore startingchatbot.py
💾 Step 3: Storing Orders in SQLite
We need a database to store order tracking details. We use SQLite, a lightweight database that’s perfect for small projects.
📌 setup_db.py (Creates the Database)
import sqlite3
# Store the database inside Docker at /app/orders.db
DB_PATH = "/app/orders.db"
# Connect to the database
conn = sqlite3.connect(DB_PATH)
cursor = conn.cursor()
# Create the orders table
cursor.execute("""
CREATE TABLE IF NOT EXISTS orders (
order_id TEXT PRIMARY KEY,
status TEXT
)
""")
# Insert some sample data
orders = [
("12345", "Shipped - Expected delivery: Feb 28, 2025"),
("67890", "Processing - Your order is being prepared."),
("11121", "Delivered - Your package was delivered on Feb 20, 2025."),
]
cursor.executemany("INSERT OR IGNORE INTO orders VALUES (?, ?)", orders)
conn.commit()
conn.close()
print("✅ Database setup complete inside Docker!")
✅ Now our chatbot can track real orders!
📦 Step 4: Building the Docker Image
📌 Dockerfile (Defines the Chatbot Container)
# Use an official Python image
FROM python:3.10
# Install SQLite inside the container
RUN apt-get update && apt-get install -y sqlite3
# Set the working directory inside the container
WORKDIR /app
# Copy project files into the container
COPY . .
# Install required Python packages
RUN pip install requests
# Expose port (optional, if we later add an API)
EXPOSE 5000
# Run the chatbot script
CMD ["python", "chatbot.py"]
# Ensure the database is set up before running
RUN python setup_db.py
📌 Build and Run in Docker
docker build -t chatbot .
docker run --network host -it chatbot
✅ Now the chatbot and database run inside Docker! 🎉
📤 Step 4: Pushing the Project to GitHub
To save our work, we pushed everything to GitHub.
📌 Steps to Push to GitHub
git init
git add .
git commit -m "Initial commit: Add chatbot with SQLite and Docker"
git branch -M main
git remote add origin https://github.com/<YOUR_REPO>/llm-chatbot.git
git push -u origin main
✅ Now the project is live on GitHub! 🎉
📌 What’s Next? (Part 2)
In Part 2, we will:
🚀 Turn the chatbot into an API with FastAPI
🎨 Build a Web UI using Streamlit
💾 Allow users to add new orders dynamically
💡 Stay tuned for Part 2! 🚀
Thank you for being a part of the community
Before you go:
- Be sure to clap and follow the writer ️👏️️
- Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Differ
- Check out CoFeed, the smart way to stay up-to-date with the latest in tech 🧪
- Start your own free AI-powered blog on Differ 🚀
- Join our content creators community on Discord 🧑🏻💻
- For more content, visit plainenglish.io + stackademic.com
Shanoj 