Project Ideas
A starting brief for a HuggingFace capstone — the problem, the shape of a solution, and the stack — left for you to build
Project Ideas
This is a brief, not a build guide
Unlike the RAG and AI Agents tracks, this page does not walk you through a full implementation. It sets up one well-scoped project idea — the problem, what a solution touches, and the stack it would use — and leaves the building to you. Everything you need conceptually is in the Fundamentals track; this is where you'd point it.
The idea: a triage assistant you fine-tune, measure, and ship
Problem: A support inbox, a moderation queue, or a bug tracker gets a stream of free-text items that all need the same first decision — what kind of thing is this, and how urgent — before a human or a downstream system acts on it. A general-purpose model can guess at this reasonably well out of the box; a small model fine-tuned on your own labelled examples does it faster, cheaper, and more consistently, and is a small enough project to actually finish.
This is a good capstone because it is the one workflow that touches nearly every library in the track, in the order you'd naturally reach for them:
One idea, the whole stack
Why this shape, specifically
Design choices worth making deliberately
A small base model, not the largest one available
RecommendedThe point is to feel the effect of fine-tuning and quantization on something you can iterate on in minutes, not to chase a leaderboard. A 1–4B model is plenty for a well-scoped classification or short-generation task, and QLoRA makes it trainable on a single consumer GPU or a rented hf jobs GPU-hour.
Measure the baseline before fine-tuning
RecommendedThe most common mistake on a first fine-tuning project is skipping straight to training. Without a zero-shot baseline scored with evaluate, you cannot tell whether the fine-tune actually helped or you just got used to its mistakes.
Ship it as an MCP-callable Space, not just a notebook
A model that only exists in a notebook is a demo. Wiring it up as a Gradio Space with mcp_server=True turns it into something both a person and an agent (this project's own agent, or Claude, or any MCP client) can actually call — which is the difference between "I trained a model" and "I shipped one."
Suggested stack
| Layer | Library | Role |
|---|---|---|
| Data | datasets | Load, split, and version your labelled set |
| Baseline | transformers (pipeline) | Zero-shot comparison point |
| Fine-tuning | peft + transformers Trainer | QLoRA on a small base model |
| Tracking | trackio | Compare runs, catch a bad hyperparameter before it wastes an hour |
| Evaluation | evaluate | Score baseline vs fine-tune on held-out data, not training data |
| Deployment | gradio on a Space, mcp_server=True | A callable, shareable, agent-reachable result |
Stretch directions, if the base project goes well
- Swap the single fine-tune for a DPO pass (Alignment with TRL) once you have enough labelled preference pairs — "this categorization is better than that one" — instead of only hard labels.
- Add a quantized export (Quantization & Optimization) so the same model also runs somewhere with no GPU at all.
- Put the Space behind the agent from the AI Agents track as one more tool it can call — the fine-tuned classifier becomes a fast, cheap first step before anything more expensive runs.
Before you start
Work through What Is HuggingFace? through Fine-Tuning with PEFT at minimum — the rest of the fundamentals track fills in as you hit each stage above. If a step above uses a term or API you haven't seen yet, that's the signal for which fundamentals page to read next, not a sign you're missing something.