Skip to content

Releases

v1.2.0

Choose a tag to compare

@Eisenmann Eisenmann released this 29 Sep 09:36
c70588d

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) — managed llama-server process per deployment: health-checked, auto-restarted, stopped via POST /deployments/{id}/stop.
  • Constrained decoding — JSON Schema → GBNF grammar generation; PredictConstrained forces 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.html page — 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

🧪 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.yml extended.

⚠️ Upgrade notes

  • No breaking changes — existing causal_lm tasks 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 (and INFERENCE_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

Choose a tag to compare

@Eisenmann Eisenmann released this 20 Sep 16:06
60960c0

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 run

For 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

Choose a tag to compare

@Eisenmann Eisenmann released this 11 Aug 18:46

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/simulation package 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 -> output example pairs directly.
  • Bulk import via CSV upload (input/output columns).
  • 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> or X-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) and embed.go.

Testing

  • Unit tests across usecases and repositories (mocks for domain ports).
  • make test runs go vet ./... and go 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 in internal/delivery/http/router.go before exposing beyond
    localhost.
  • Training and inference are simulated; swap adapters in
    internal/infra/simulation to 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.