Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.9-slim
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy all files from the current directory to the container's working directory
+COPY . .
+
+# Install dependencies from the requirements file without using cache to reduce image size
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Define the command to start the application using Gunicorn with 4 worker processes
+# - `-w 4`: Uses 4 worker processes for handling requests
+# - `-b 0.0.0.0:7860`: Binds the server to port 7860 on all network interfaces
+# - `app:app`: Runs the Flask app (assuming `app.py` contains the Flask instance named `app`)
+CMD ["gunicorn", "-w", "1", "-b", "0.0.0.0:7860", "app:app"]

app.py

@@ -0,0 +1,170 @@
+import os, io, base64, torch, logging
+import pandas as pd
+import matplotlib.pyplot as plt
+from flask import Flask, request, jsonify
+from sqlalchemy import create_engine, inspect
+from model_loader import load_model
+
+# -------------------------------------------------------
+# 🧠 Flask App Setup
+# -------------------------------------------------------
+app = Flask("ChatBot-Backend")
+
+# -------------------------------------------------------
+# 🧾 Logging Configuration
+# -------------------------------------------------------
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+logging.basicConfig(
+    level=LOG_LEVEL,
+    format="[%(asctime)s] [%(levelname)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger("ChatBot")
+
+logger.info("🚀 Starting ChatBot backend service...")
+
+# -------------------------------------------------------
+# ⚙️ Database Configuration
+# -------------------------------------------------------
+DB_USER     = os.getenv("DB_USER", "root")
+DB_PASSWORD = os.getenv("DB_PASSWORD", "root1234")
+DB_HOST     = os.getenv("DB_HOST", "database-1.chks4awear3o.eu-north-1.rds.amazonaws.com")
+DB_PORT     = os.getenv("DB_PORT", "3306")
+DB_NAME     = os.getenv("DB_NAME", "chatbot_db")
+
+# -------------------------------------------------------
+# 🧩 Database Engine Setup
+# -------------------------------------------------------
+try:
+    engine = create_engine(f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}")
+    insp = inspect(engine)
+    logger.info("✅ Connected to MySQL successfully.")
+except Exception as e:
+    logger.error(f"❌ Database connection failed: {e}")
+    engine = None
+
+# -------------------------------------------------------
+# 🧠 Model and Schema
+# -------------------------------------------------------
+tokenizer, model = None, None
+schema_description = ""
+
+def build_schema_description():
+    """Builds schema text dynamically from MySQL tables."""
+    global schema_description
+    if not engine:
+        schema_description = "⚠️ Database connection unavailable."
+        return
+    try:
+        schema_description = ""
+        for table in insp.get_table_names():
+            schema_description += f"Table: {table}\n"
+            for col in insp.get_columns(table):
+                schema_description += f"  - {col['name']} ({col['type']})\n"
+            schema_description += "\n"
+        logger.info("📘 Schema description built successfully.")
+    except Exception as e:
+        logger.error(f"⚠️ Error while building schema: {e}")
+        schema_description = f"⚠️ Schema fetch error: {e}"
+
+def generate_sql(question: str) -> str:
+    """Generates SQL query from user question using the model."""
+    if tokenizer is None or model is None:
+        raise RuntimeError("Model not loaded yet.")
+    logger.info(f"🧩 Generating SQL for: {question}")
+
+    prompt = (
+        "You are a professional SQL generator.\n"
+        "Convert the following question into a valid SQL query based on this schema:\n\n"
+        f"{schema_description}\n"
+        f"Question: {question}\n\nSQL:"
+    )
+
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True).to(model.device)
+    with torch.no_grad():
+        outputs = model.generate(**inputs, max_new_tokens=200, temperature=0.2, do_sample=False)
+
+    sql = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    if "SELECT" in sql.upper():
+        sql = sql[sql.upper().find("SELECT"):]
+    sql = sql.strip()
+    logger.info(f"🧠 Generated SQL: {sql}")
+    return sql
+
+
+@app.before_first_request
+def init_model():
+    """Loads the model and builds schema once before first API call."""
+    global tokenizer, model
+    logger.info("🪄 Initializing model on first request...")
+    tokenizer, model = load_model()
+    model.eval()
+    build_schema_description()
+    logger.info("✅ Model loaded and schema ready.")
+
+
+# -------------------------------------------------------
+# 🌐 Routes
+# -------------------------------------------------------
+@app.route("/")
+def home():
+    return jsonify({"message": "Chatbot backend is running!"})
+
+
+@app.route("/api/ask", methods=["POST"])
+def ask():
+    """Main API endpoint for answering user queries."""
+    try:
+        data = request.get_json(force=True)
+    except Exception as e:
+        logger.error(f"❌ Invalid JSON received: {e}")
+        return jsonify({"error": "Invalid JSON payload"}), 400
+
+    question = data.get("question", "").strip()
+    if not question:
+        return jsonify({"error": "Empty question"}), 400
+
+    logger.info(f"🗨️ Received question: {question}")
+
+    try:
+        sql = generate_sql(question)
+        df = pd.read_sql(sql, engine)
+        logger.info(f"✅ SQL executed successfully, {len(df)} rows fetched.")
+
+        if df.empty:
+            return jsonify({"answer": "No relevant data found in the database."})
+
+        html_table = df.to_html(index=False, classes="table table-striped")
+
+        # Plot graph
+        chart_base64 = None
+        try:
+            if len(df.columns) >= 2:
+                plt.figure(figsize=(6, 4))
+                df.plot(x=df.columns[0], y=df.columns[1], kind="bar")
+                plt.title(question)
+                plt.tight_layout()
+
+                buf = io.BytesIO()
+                plt.savefig(buf, format="png")
+                buf.seek(0)
+                chart_base64 = base64.b64encode(buf.read()).decode("utf-8")
+                plt.close()
+                logger.info("📈 Chart generated successfully.")
+        except Exception as plot_err:
+            logger.warning(f"⚠️ Chart generation failed: {plot_err}")
+
+        return jsonify({
+            "answer": f"Here’s what I found:<br>{html_table}",
+            "chart": chart_base64
+        })
+
+    except Exception as e:
+        logger.exception(f"❌ Error processing request: {e}")
+        return jsonify({"answer": f"⚠️ Error: {str(e)}"})
+
+# -----------------------
+# Run Flask app
+# -----------------------
+if __name__ == '__main__':
+    app.run(debug=True)

model_loader.py

@@ -0,0 +1,27 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import os
+
+MODEL_NAME = "Yuk050/gemma-3-1b-text-to-sql-model"
+LOCAL_DIR = "./model_cache"
+
+_tokenizer = None
+_model = None
+
+def load_model():
+    global _tokenizer, _model
+    if _tokenizer is not None and _model is not None:
+        return _tokenizer, _model
+
+    print("🔄 Loading model...")
+    if os.path.exists(LOCAL_DIR):
+        _tokenizer = AutoTokenizer.from_pretrained(LOCAL_DIR)
+        _model = AutoModelForCausalLM.from_pretrained(LOCAL_DIR, trust_remote_code=True)
+    else:
+        _tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        _model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, trust_remote_code=True)
+        os.makedirs(LOCAL_DIR, exist_ok=True)
+        _tokenizer.save_pretrained(LOCAL_DIR)
+        _model.save_pretrained(LOCAL_DIR)
+
+    print("✅ Model loaded successfully!")
+    return _tokenizer, _model

requirements.txt

@@ -0,0 +1,20 @@
+# Core AI libraries
+transformers>=4.47.0
+accelerate>=1.0.0
+safetensors>=0.4.5
+torch==2.4.1
+torchvision==0.19.1
+torchaudio==2.4.1
+
+# Data + DB
+sqlalchemy==2.0.36
+pymysql==1.1.1
+pandas==2.2.3
+requests==2.32.3
+matplotlib==3.9.2
+
+# Web server
+flask==2.2.2
+werkzeug==2.2.3
+gunicorn
+uvicorn[standard]