Hugging Face Skills

The hf CLI is used for managing models, datasets, spaces, buckets, repos, papers, jobs, and more on the Hugging Face Hub. Use hf --help to view all available functions.

Key command groups include:

• hf auth: Manage authentication (e.g., hf auth whoami).
• hf buckets: Interact with buckets.
• hf cache: Manage local cache directory.
• hf collections: Interact with collections.
• hf datasets: Interact with datasets.
• hf discussions: Manage discussions and pull requests.
• hf endpoints: Manage Hugging Face Inference Endpoints.
• hf extensions: Manage hf CLI extensions.
• hf jobs: Run and manage Jobs on the Hub.

The huggingface-paper-publisher skill allows AI engineers and researchers to publish and manage research papers on the Hugging Face Hub.

Key capabilities include:

• Paper Page Management: Indexing papers from arXiv, claiming authorship, and managing profile visibility.
• Artifact Linking: Connecting papers to Models or Datasets via metadata, adding citations to model cards, and utilizing automatic arxiv:<PAPER_ID> tagging.
• Research Article Creation: Generating professional markdown-based research articles with LaTeX math support, dynamic Tables of Contents (TOC), and standard scientific section structures.
• Metadata Management: Using YAML frontmatter for model/dataset cards and maintaining citation tracking across repositories.

Use this skill to run evaluations against Hugging Face Hub models on local hardware. It supports inspect-ai for explicit task control and lighteval for leaderboard-style benchmarks. You can choose between vllm for high throughput, or fallback to Hugging Face Transformers (--backend hf) or accelerate for compatibility.

Note: This skill is for local execution only. To run these evaluations on remote hardware, hand off to the hugging-face-jobs skill using the same scripts and arguments.

The huggingface-lora-space-builder skill is used to build and publish a Gradio demo on Hugging Face Spaces for a user-provided LoRA. This is applicable when a user wants to create, generate, ship, or publish a Space, demo, Gradio app, or playground for LoRAs targeting models like Qwen-Image, Qwen-Image-Edit, LTX-Video, Wan, FLUX, or SDXL.

By default, the skill targets ZeroGPU hardware and uses the diffusers library for inference when supported. The output is a real, published (private by default) Space rather than a local script.

The hf-llm-trainer/ skill allows you to fine-tune and share models on the Hugging Face Hub. It supports several training methodologies and leverages HF Jobs for cloud GPU training, eliminating the need for local hardware setup.

Key Capabilities:

• SFT (Supervised Fine-Tuning): Standard instruction tuning.
• DPO (Direct Preference Optimization): Alignment using preference data.
• GRPO (Group Relative Policy Optimization): Online Reinforcement Learning (RL) training.
• Cloud GPU Training: Submit jobs directly to HF infrastructure via hf_jobs().
• Monitoring: Real-time monitoring via Trackio integration.
• Deployment: GGUF conversion for local deployment.

The hf-cloud-sagemaker-deployment-planner skill is the entry point for planning and coordinating model deployments to Amazon SageMaker AI. Use this skill when you want to deploy, host, serve, or expose a model on SageMaker or AWS (e.g., 'deploy a model', 'host this LLM on AWS', 'create an endpoint').

It works for various model types including text-generation LLMs, embedding models, rerankers, classifiers, and text-to-image/diffusion models. The skill handles the initial discovery and pathway selection, then coordinates specialized skills for context discovery, IAM preflight, image selection, and final deployment.

In Transformers.js v4, ModelRegistry provides a preflight API to inspect model assets, estimate download sizes, and check cache status before calling pipeline(). This is useful for managing bandwidth and supporting offline-first workflows.

Import ModelRegistry from @huggingface/transformers and use the same task, modelId, and modelOptions tuple that you would pass to pipeline().

import { ModelRegistry } from '@huggingface/transformers';

const task = 'feature-extraction';
const modelId = 'onnx-community/all-MiniLM-L6-v2-ONNX';
const modelOptions = { dtype: 'fp32' };

A ZeroGPU Space operates using two distinct processes with different lifetimes:

1. Main web process: A long-lived process that imports app.py and runs the Gradio server. It holds no VRAM and, after the startup "pack" step, holds no model weights in RAM. It does not have a GPU attached.
2. GPU worker processes: Short-lived processes forked per @spaces.GPU request (or reused if warm). These processes run the actual GPU tasks and are managed/killed by the ZeroGPU scheduler, not by your code.

Because of this separation, you cannot perform GPU-bound operations (like model.generate()) at the module scope in the main process.

All sparse-encoder evaluators are located in sentence_transformers.sparse_encoder.evaluation. They use dot product similarity by default. Select an evaluator based on your specific task: