Repository navigation
Releases
v1.2.0
Release Notes — v1.2.0
Release date: 2026-09-29
Distillery expands from a single causal-LM fine-tuner into a multi-kind task-to-model platform: 10 model kinds, a real llama.cpp serving backend, and schema-constrained decoding.
✨ Added
New model kinds (1 → 10)
| Kind | What it does | PR |
|---|---|---|
seq_classifier |
Text classification — label + confidence scores (sentiment, intent, topic, spam) | #3 |
token_classifier |
NER / token classification — labeled spans (people, orgs, dates, PII, custom) | #5 |
embedding / reranker |
Bi-encoder embeddings + cross-encoder rerankers; /embed, /rerank, /embed-corpus; nDCG@10 / MRR / recall base-vs-tuned |
#4 |
preference_lm |
Preference alignment via DPO from (chosen, rejected) pairs | #6 |
vision_lm |
Document AI with Qwen2-VL — ZIP/PDF import (auto-rasterized), multipart /predict, field-level exact-match/F1, ANLS, JSON validity |
#7 |
asr |
Whisper speech-to-text — speaker-grouped splits, WER/CER vs base, domain-glossary recall, /transcribe |
#8 |
tabular |
Gradient-boosted classification/regression on CSV (LightGBM / XGBoost / CatBoost, numpy fallback); SHAP, Platt calibration, leakage warnings | — |
time_series |
Forecasting with 80% intervals — seasonal naive / drift / SES / Holt-Winters / lag-GBM; rolling-origin backtests ranked by MASE; /forecast |
— |
Platform & infrastructure
- Common training infrastructure — Python trainer refactored into task modules (
trainer/tasks/{sft,classifier,ner,embedding,reranker,dpo,vision,asr,tabular,forecast}.py) behind a single config schema; per-kind dataset registry with validation, stats and bulk importers. - llama.cpp inference backend (
INFERENCE_BACKEND=llamacpp) — managedllama-serverprocess per deployment: health-checked, auto-restarted, stopped viaPOST /deployments/{id}/stop. - Constrained decoding — JSON Schema → GBNF grammar generation;
PredictConstrainedforces schema-valid JSON output for extraction tasks. - Local blob store (
internal/infra/blob) — stores images, rasterized PDF pages and audio;GET /api/v1/tasks/{taskID}/blobs/{key}. - PDF rasterizer — one rendered page image per example (
internal/infra/pdfraster,trainer/pdf_rasterize.py).
Web UI
- New
/tabular.htmlpage — CSV upload, column mapper with leakage/frequency hints, training form, live progress, leaderboard, importance, ROC / confusion matrix / residuals, backtest chart, batch predict/forecast. - Per-kind dataset forms and metric renderings (WER, nDCG, F1, MASE, …) across Tasks and Models pages.
📚 Documentation
- New guides: embeddings-rerankers, vision-language-document-ai, speech-asr, tabular-forecasting.
- README updated with the multi-kind architecture and new endpoints.
🧪 Tests & tooling
- Go end-to-end suites: import → train → deploy → predict / forecast / embed / rerank, error contracts, metrics propagation (
go test -race ./...). - Python per-task unit tests (
trainer/tests/,python -m pytest). - Docker image installs
trainer[gguf,tabular]extras;.golangci.ymlextended.
⚠️ Upgrade notes
- No breaking changes — existing
causal_lmtasks work as before (migrated to the default kind automatically). - Simulation backend remains the default for every kind (full flow without a GPU). For real training/serving: set
TRAINING_BACKEND=local(andINFERENCE_BACKEND=llamacpp) +pip install -r trainer/requirements.txt. - Optional dependencies (
statsforecast, Chronos,torchao) are guarded, experimental and never required.
📦 New API endpoints (selected)
POST /api/v1/tasks/{taskID}/examples/import-vision-zip | import-vision-pdf | import-asr-zip
POST /api/v1/inference/{id}/embed | /rerank | /embed-corpus | /transcribe | /forecast | /predict-batch
POST /api/v1/tasks/{taskID}/tables (CSV upload for tabular)
POST /api/v1/tasks/{taskID}/training/tabular | /training/forecast
GET /api/v1/tasks/{taskID}/tables/{id}/preview
v1.1.0
Release Notes — v1.1.0: Fine-Tuning & Model Customization
🌟 Highlights
Distillery now supports full LLM fine-tuning — take your datasets, train custom models on GPU, and deploy them through the platform. This release turns Distillery from a model-serving tool into a complete training-to-deployment platform.
🚀 New Features
Fine-Tuning Pipeline
- End-to-end fine-tuning workflow: define datasets → configure training → run GPU-accelerated training → export → deploy
- Local training engine with robust GGUF support (quantization, tensor mapping, metadata, progress tracking)
- New JSONL dataset format support
- Qwen3 RoPE encoding repair utility
Model Store
- Manage your trained and base models: upload, download, list, and delete
- Transfer models between local and remote storage
- Model selection for training and deployment
Agent Capabilities
- New coding agent with pluggable LLM providers
- Reflection agent for iterative self-improvement
- Extensible typed tool registry
- Code parsing utilities for source-level analysis
Web UI
- New agent configuration page
- Model store management page
- Enhanced dashboard
🛠️ Improvements & Infrastructure
| Area | Description |
|---|---|
| Data Store | Expanded schema: agents, fine-tunes, model store, deployments, tasks, training |
| Code Quality | Significantly improved linter configuration; exhaustive struct checks |
| Containerization | Updated Dockerfile and Makefile for new components |
| Testing | +29k lines of test coverage across all layers |
| Tooling | Pull-models script for automated model downloads |
🧩 Breaking Changes
Note: This is a v1.1.0 release; consider the following when upgrading:
- Data store schema (
data/distillery.json) has been extended significantly. On first run with new data, existing stores may need migration or re-initialization. - Makefile targets and build commands may have changed — review
make help. - HTTP API routes were reorganized (new handlers for agents, models, fine-tunes). Update any external API integrations accordingly.
📦 Installation / Upgrade
git pull origin feature/fine-tuning
make build # or follow README instructions
make runFor GPU training, see the new trainer/ directory instructions in README.md.
🔧 Known Issues / Notes
- Fine-tuning requires a compatible NVIDIA GPU for best performance (CPU fallback available but slow)
- Large dataset files (>1GB) may take time to parse; consider streaming formats
- GGUF export is verified for Qwen-family models; other architectures may need additional tuning
✅ What's Next
- Multi-GPU distributed training
- Cloud storage integration (S3-compatible)
- Hyperparameter sweeps / auto-tuning
- Dataset versioning and lineage tracking
v1.0.0
Release Notes — Distillery v1.0.0
Release date: 2026-08-11
Tag: v1.0.0
Commit: 38ddbcf
Go version: 1.26.5
The first stable release of Distillery — No-Code Fine-Tuning (Task-to-Model Platform).
Distillery is a single-binary MVP of the "define a task, get a model" pipeline:
task definition → dataset curation → automatic base-model selection → managed
fine-tuning → one-click deployment → portable export → continuous
improvement loop. It runs the same way on the desktop or in a container, with
no third-party Go dependencies (standard library only).
Note on scope: GPU fine-tuning, model serving, and the frontier-model
synthetic-data bootstrap are simulated in this release so the full product
flow can be exercised end-to-end without GPUs or API keys. The
internal/infra/simulationpackage is the seam where real implementations
can be swapped in.
Highlights
Task management
- Create tasks in plain English and pick a type: classification, extraction,
or generation. - Task list with per-task dataset/training/deployment state.
Dataset curation
- Paste
input -> outputexample pairs directly. - Bulk import via CSV upload (
input/outputcolumns). - Generate synthetic variations to bootstrap a seed set.
- Automatic deduplication, low-quality row flagging, and live
label-balance / dataset-readiness checks. - Inline edit and delete of individual examples.
Fine-tuning
- Automatic right-sized base-model selection from a curated catalog.
- Simulated LoRA/QLoRA fine-tune with live progress.
- Every completed run is kept as a numbered version.
- Any version can be deployed; deploying an older version acts as an
instant rollback.
Deploy & test
- One-click deploy a model as an API endpoint.
- Deployment issues an API key shown exactly once; predictions require
Authorization: Bearer <key>orX-API-Key: <key>. Only the SHA-256 hash
is persisted. - Single-prediction testing inline.
- Batch inference: upload a CSV/text file of inputs, download a CSV of
predictions. - Portable export package: Dockerfile + manifest + adapter placeholder
to self-host anywhere. - Redeploying (including rollback) issues a fresh key and invalidates the
previous one.
Feedback loop
- Log production mispredictions and fold them back into the dataset ahead
of the next retrain.
Web UI
- Embedded single-page UI (vanilla JS, no build step).
- Tabs: Tasks, Dataset, Fine-Tuning, Deploy & Test, Feedback Loop, API Docs.
- Built-in favicon/logo assets.
Architecture
Clean / ports-and-adapters architecture; dependency direction flows inward
and internal/domain has no external dependencies.
cmd/server/main.go wiring / composition root
internal/domain/ entities + repository & service interfaces (ports)
internal/usecase/ application/business logic
internal/repository/memory/ in-memory store + JSON snapshot persistence
internal/infra/simulation/ simulated fine-tuning, inference, export, etc
internal/delivery/http/ HTTP handlers + router (Go 1.22 stdlib ServeMux)
web/ embedded single-page UI
No third-party Go dependencies — builds anywhere with no go.sum/network
access required.
Distribution
Desktop
make run
# or
go build -o distillery ./cmd/server && ./distillery
Opens http://localhost:8080 automatically; data persists to
./data/distillery.json.
Container
make docker-build
make docker-run
# or
docker build -t distillery .
docker run --rm -p 8080:8080 -v distillery-data:/data distillery
PORT, DATA_PATH, and OPEN_BROWSER are configurable env vars.
API
All endpoints under /api/v1. Representative endpoints:
POST /api/v1/tasks
GET /api/v1/tasks/{taskID}
POST /api/v1/tasks/{taskID}/examples
POST /api/v1/tasks/{taskID}/examples/import
PUT /api/v1/tasks/{taskID}/examples/{exampleID}
DELETE /api/v1/tasks/{taskID}/examples/{exampleID}
POST /api/v1/tasks/{taskID}/examples/synthetic
GET /api/v1/tasks/{taskID}/dataset/stats
POST /api/v1/tasks/{taskID}/training
GET /api/v1/training/{jobID}
POST /api/v1/tasks/{taskID}/deploy
POST /api/v1/tasks/{taskID}/training/{jobID}/deploy
POST /api/v1/inference/{deploymentID}/predict
POST /api/v1/inference/{deploymentID}/batch
GET /api/v1/tasks/{taskID}/export
POST /api/v1/tasks/{taskID}/feedback
POST /api/v1/tasks/{taskID}/feedback/fold
GET /healthz
Included components
cmd/server— composition root + startup wiring.internal/domain— entities, errors, and interface definitions
(TaskRepository,FineTuner,InferenceEngine,Exporter,
SyntheticGenerator, etc.).internal/usecase— application logic (task, dataset, training,
deployment, feedback) with unit tests and mocks.internal/repository/memory— in-memory store with JSON snapshot
persistence and repository tests.internal/infra/simulation— simulated trainer, inference engine,
exporter, synthetic generator, and model selector adapters.internal/delivery/http— HTTP handlers, DTOs, and stdlib router.web/— embedded UI (HTML/CSS/JS) andembed.go.
Testing
- Unit tests across usecases and repositories (mocks for domain ports).
make testrunsgo vet ./...andgo build ./....
Known simplifications (MVP)
- Single-node persistence (JSON snapshot guarded by an in-process mutex);
not suitable for horizontally-scaled multi-instance deployment. - The task-management API (
/api/v1/tasks/...) has no auth — add
middleware ininternal/delivery/http/router.gobefore exposing beyond
localhost. - Training and inference are simulated; swap adapters in
internal/infra/simulationto integrate real GPU jobs and model servers.
Upgrading
This is the initial release; no upgrade path is required. To start from a
clean state, delete data/distillery.json.