I Thought Fine-Tuning LLMs Needed Expensive GPUs. I Was Wrong.

Yesterday I fine-tuned a 1.1B parameter language model using QLoRA on consumer hardware.

And honestly?

The hardest part wasn’t training.
It was debugging everything around it.

I started with a simple goal:
“understand how LLM fine-tuning actually works.”
A few hours later I was deep into:

NF4 quantization
LoRA internals
tokenization
chat templates
VRAM optimization
adapter injection
FastAPI serving
Redis caching
Qdrant RAG pipelines
and dependency version warfare

This was the stack:
TinyLlama
QLoRA
PEFT
TRL
BitsAndBytes
Hugging Face
FastAPI
The Crazy Part

I trained only ~0.2% of the model.
Not 20%.
Not 2%.
0.2%.

That’s the magic of LoRA.

Instead of retraining the full model, you train tiny adapter matrices on top of frozen weights.
And with 4-bit NF4 quantization, memory usage drops enough to make this possible on low VRAM hardware.
That moment blew my mind.

The Funniest Bug
Training loss looked good.
Everything seemed successful.
Then inference output came out completely broken.

Why?

Because the inference prompt format didn’t match the training chat template.
One formatting mismatch destroyed the entire output quality.
That single bug taught me more than most tutorials online.
Biggest Takeaway
AI engineering is not:
“call OpenAI API and ship.”

The real stuff starts when you understand:

quantization
tokenization
adapters
training loops
inference pipelines
deployment tradeoffs

That’s when you stop being an API consumer and start understanding the actual systems underneath.

What I Built 🚀

✅ Fine-tuned TinyLlama-1.1B using QLoRA
✅ Trained only ~2.25M params out of ~1.1B
✅ Built FastAPI inference pipeline
✅ Saved adapter-only weights
✅ Pushed model adapter to Hugging Face
✅ Built interactive dark-mode revision cheatsheet
✅ Explored Redis + Qdrant RAG concepts

Open Source AI Is Wild

Huge respect to:
Hugging Face
TinyLlama
PEFT
TRL
BitsAndBytes

The tooling available for solo developers right now is insane.

Links

🤗 Hugging Face Repo

whyvickyyy/agent-forge-support-agent · Hugging Face

We’re on a journey to advance and democratize artificial intelligence through open source and open science.

huggingface.co

💻 GitHub Repo

0xvicky / agent-forge

Production-Oriented QLoRA Fine-Tuning & LLMOps Pipeline
Fine-tuned TinyLlama using QLoRA, PEFT, TRL, and the HuggingFace ecosystem
with a deployment-oriented inference architecture

---

🚀 Overview

Agent-Forge is a production-oriented GenAI engineering project that implements the complete lifecycle of modern LLM adaptation and deployment — from raw dataset to containerized inference server.

🎯 Goal: Deeply understand and implement end-to-end LLM fine-tuning & deployment infrastructure.

🧠 ML Engineering QLoRA Fine-Tuning 4-bit NF4 Quantization PEFT / LoRA Adapters Supervised Fine-Tuning (SFT) Conversational Dataset Engineering

⚙️ LLMOps & Infra FastAPI Inference Serving Redis Caching Architecture Qdrant RAG Integration Docker Containerization Deployment-Ready Pipelines

---

🏗️ Architecture

  HuggingFace Dataset
          │
          ▼
  Conversational Formatting
          │
          ▼
  Tokenizer (TinyLlama)
          │
          ▼
  4-bit NF4 Quantization  ◄──── BitsAndBytes
          │
          ▼
  QLoRA + PEFT Adapter Injection
          │
          ▼
  SFT Training  (SFTTrainer / TRL)
          │
          ▼
  Inference Evaluation (Before vs After)
          │
          ▼
  LoRA Adapter Saving
          │
          ▼
  FastAPI Inference Server
          │
          ▼
  Redis +

…

View on GitHub

If you’re learning AI:
don’t just use models.

Learn how they’re built, trained, optimized, and deployed.