← all publishers

Hugging Face

@huggingface source repo

Report this profile Claim this profile

• 106 skills
• 0 followers
• 11k repo stars
• 35 verified
• last week last updated

1. ▌
   Pwc MCP · huggingface bundle

   Papers With Code MCP tools for searching and reading AI/ML papers, discovering recent and trending research, finding related work and paper lineage, browsing tasks, methods, conferences, organizations, and frameworks, and inspecting benchmark leaderboards with model-size and metric filters through the public Papers With Code catalog. Use whenever the user asks to find papers, survey literature, compare research, inspect an arXiv paper, explore AI/ML taxonomy or conferences, discover benchmarks or state-of-the-art models, or mentions Papers With Code, the PwC MCP server, or paperswithcode.co/mcp.
   10.8k repo stars
2. ▌
   Pwc CLI · huggingface bundle

   Papers With Code CLI (`pwc`) for searching and reading AI/ML papers, discovering recent and trending research, finding related work and paper lineage, browsing tasks, methods, conferences, organizations, frameworks, and benchmark leaderboards, and submitting authenticated paper edits through the public Papers With Code catalog. Use whenever the user asks to find papers, survey literature, compare research, inspect an arXiv paper, explore AI/ML taxonomy or conferences, discover benchmarks or state-of-the-art models, or mentions Papers With Code, `pwc`, or `pwc-cli`.
   10.8k repo stars
3. ▌
   Hf Cloud Sagemaker Iam Preflight 2 · huggingface bundle

   Ensure a usable SageMaker execution role exists before deploying or training. Use this skill whenever about to create a SageMaker endpoint, model, training job, or any resource that requires an execution role. Use it especially when the user has not provided a role ARN explicitly, when scripts are about to call `iam:CreateRole`, or when an AccessDenied error mentions an IAM action. Never blindly call `iam:CreateRole` — always check for existing roles first. This skill prevents the most common SageMaker deployment failure: trying to create IAM resources from an SSO principal that has no IAM write permissions.
   10.8k repo stars
4. ▌
   Hf Cloud Serving Image Selection 2 · huggingface bundle

   Pick the right serving container for a SageMaker model deployment and find its current image URI. Use this skill whenever about to deploy a model to a SageMaker endpoint and an image URI needs to be chosen — including when the user says "deploy this LLM", "host this HuggingFace model", "serve this fine-tuned model", "deploy this embedding model", "host a reranker", "serve a sentence-transformers model", or when about to hardcode any container URI in deployment code. HuggingFace-curated Deep Learning Containers are ALWAYS preferred: HuggingFace vLLM (LLMs and generative rerankers), HuggingFace vLLM-Omni (multimodal), TEI (embeddings/cross-encoder rerankers), HF Inference Toolkit (other transformers). Generic images (AWS vLLM, DJL-LMI, SGLang) are used only when no HuggingFace image is compatible — never merely because they carry a newer version. Never hardcode a container URI from memory and never default to TGI. Prevents stale-image failures and wrong-region URIs.
   10.8k repo stars
5. ▌
   Hf Cloud Sagemaker Deployment Planner 2 · huggingface

   Plan and coordinate the deployment of a model to Amazon SageMaker AI. Use this skill whenever the user wants to deploy, host, serve, or expose a model on SageMaker or AWS — including phrases like "deploy a model", "host this LLM on AWS", "serve this embedding model", "deploy a reranker", "deploy a text-to-image / diffusion model", "host this for async inference", "create an endpoint", "serve my fine-tuned model", or any request that involves making a model available for inference on AWS. Use this even when the user is vague (e.g. "I just want to get this running on AWS, you figure it out"). Works for text-generation LLMs, embedding models, rerankers, classifiers, text-to-image / diffusion models — picks the right serving stack and chooses between real-time and async inference. This is the entry-point skill for SageMaker deployment work — it asks clarifying questions, picks a deployment pathway, and coordinates the other deployment skills.
   10.8k repo stars
6. ▌
   Hf Cloud Sagemaker Production Defaults 2 · huggingface bundle

   Create a SageMaker endpoint (real-time, real-time scale-to-zero, or async) with autoscaling, CloudWatch alarms, and tagging enabled by default. Use this skill whenever about to create a SageMaker endpoint, write deployment code that calls `create_endpoint`, or finalize a deployment after the image URI and IAM role are known. Provides deploy.py for real-time endpoints, deploy_ic.py for real-time endpoints that scale to zero instances via inference components, and deploy_async.py for async endpoints (also scale-to-zero). This is the last step in the SageMaker deployment workflow. Never generate a bare `create_endpoint` call without these defaults — endpoints without autoscaling or alarms are demos, not deployments.
   10.8k repo stars
7. ▌
   Hf CLI 3 · huggingface

   Hugging Face Hub CLI (`hf`) for downloading, uploading, and managing models, datasets, spaces, buckets, repos, papers, jobs, and more on the Hugging Face Hub. Use when: handling authentication; managing local cache; managing Hugging Face Buckets; running or scheduling jobs on Hugging Face infrastructure; managing Hugging Face repos; discussions and pull requests; browsing models, datasets and spaces; reading, searching, or browsing academic papers; managing collections; querying datasets; configuring spaces; setting up webhooks; or deploying and managing HF Inference Endpoints. Make sure to use this skill whenever the user mentions 'hf', 'huggingface', 'Hugging Face', 'huggingface-cli', or 'hugging face cli', or wants to do anything related to the Hugging Face ecosystem and to AI and ML in general. Also use for cloud storage needs like training checkpoints, data pipelines, or agent traces. Use even if the user doesn't explicitly ask for a CLI command. Replaces the deprecated `huggingface-cli`.
   10.8k repo stars
8. ▌
   Trl Training 3 · huggingface

   Post-train LLMs with TRL (Transformers Reinforcement Learning) — SFT, DPO, GRPO, KTO, and reward-model training. Use when writing or debugging training code with the TRL Python API or the trl CLI.
   10.8k repo stars
9. ▌
   Funes · huggingface

   Persistent memory over the user's past AI coding sessions, searched and read through the funes MCP tools. Use when the user refers to earlier work, asks what memory is available, or when a past session may already have settled the question.
   10.8k repo stars
10. ▌
    Investigate Run 2 · huggingface

    Post-mortem analysis of a PhysicsIntern workspace run (Claude Code, Pi, Codex, or OpenCode host). Reconstructs the trajectory from the session record — JSONL file(s) for Claude/Pi/Codex, the SQLite store for OpenCode — audits methodology adherence against the workspace's own CLAUDE.md / AGENTS.md and skill/agent prompts, checks commit discipline and flag dispositions, and assesses substantive quality. Produces a thorough evidence-anchored markdown report. Use after a workspace has been worked on to identify what went well, where the methodology slipped, and what prompts to improve.
    10.8k repo stars
11. ▌
    Release 2 · huggingface

    Cut a new transformers-mlinter release. Bumps the version across all pinned locations, updates the CHANGELOG, runs local checks and a packaged smoke test, drives the tag-based GitHub Actions publish to PyPI, then opens the next development version on main. Use when asked to release, cut a version, or ship X.Y.Z.
    10.8k repo stars
12. ▌
    Hf CLI 2 · huggingface

    Hugging Face Hub CLI (`hf`) for downloading, uploading, and managing models, datasets, spaces, buckets, repos, papers, jobs, and more on the Hugging Face Hub. Use when: handling authentication; managing local cache; managing Hugging Face Buckets; running or scheduling jobs on Hugging Face infrastructure; managing Hugging Face repos; discussions and pull requests; browsing models, datasets and spaces; reading, searching, or browsing academic papers; managing collections; querying datasets; configuring spaces; setting up webhooks; or deploying and managing HF Inference Endpoints. Make sure to use this skill whenever the user mentions 'hf', 'huggingface', 'Hugging Face', 'huggingface-cli', or 'hugging face cli', or wants to do anything related to the Hugging Face ecosystem and to AI and ML in general. Also use for cloud storage needs like training checkpoints, data pipelines, or agent traces. Use even if the user doesn't explicitly ask for a CLI command. Replaces the deprecated `huggingface-cli`.
    10.8k repo stars
13. ▌
    Trl Training 2 · huggingface

    Train and fine-tune transformer language models using TRL (Transformers Reinforcement Learning). Supports SFT, DPO, GRPO, KTO, RLOO and Reward Model training via CLI commands.
    10.8k repo stars
14. ▌
    Huggingface Best 3 · huggingface

    Use when the user asks about finding the best, top, or recommended model for a task, wants to know what AI model to use, or wants to compare models by benchmark scores. Triggers on: "best model for X", "what model should I use for", "top models for [task]", "which model runs on my laptop/machine/device", "recommend a model for", "what LLM should I use for", "compare models for", "what's state of the art for", or any question about choosing an AI model for a specific use case. Always use this skill when the user wants model recommendations or comparisons, even if they don't explicitly mention HuggingFace or benchmarks.
    10.8k repo stars
15. ▌
    Huggingface Spaces 3 · huggingface bundle

    Build, deploy, and maintain applications on Hugging Face Spaces — Gradio / Docker / Static SDKs, ZeroGPU and dedicated hardware, model loading, debugging, buckets, inference providers, community grants. Use whenever the user asks to create or host an app on Hugging Face, port code onto ZeroGPU, fix a Space that won't build or run, or otherwise work with `hf spaces …`, `@spaces.GPU`, Space README frontmatter, or the `spaces` Python package.
    10.8k repo stars
16. ▌
    Huggingface Lora Space Builder 2 · huggingface bundle

    Build and publish a Gradio demo on Hugging Face Spaces for a user-provided LoRA. Use when someone asks to create, generate, ship, or publish a Space, demo, Gradio app, or playground for a LoRA — including LoRAs for Qwen-Image, Qwen-Image-Edit, LTX-Video, Wan, FLUX, SDXL, or other diffusion base models. Also triggers when someone describes a LoRA they trained or hosts on the Hub and wants to share it. Covers picking the right base pipeline and `diffusers` inference recipe, designing a UI tailored to the LoRA's task and inputs (Union/multi-task control, edit, video, image, etc.), respecting model-card recommendations (trigger words, steps, guidance, LoRA scale, example inputs), and shipping to ZeroGPU hardware as a private Space by default.
    10.8k repo stars
17. ▌
    Train Sentence Transformers 2 · huggingface bundle

    Train or fine-tune sentence-transformers models across `SentenceTransformer` (bi-encoder, dense or static embedding model for retrieval, similarity, clustering, classification, paraphrase mining, dedup, multimodal), `CrossEncoder` (reranker, pair scoring for two-stage retrieval / pair classification), `SparseEncoder` (SPLADE, sparse embedding model for learned-sparse retrieval), and `MultiVectorEncoder` (ColBERT / late-interaction, per-token embeddings scored with MaxSim). Covers loss selection, hard-negative mining, evaluators, distillation, LoRA, Matryoshka, and Hugging Face Hub publishing. Use for any sentence-transformers training task.
    10.8k repo stars
18. ▌
    Init Physics Intern 3 · huggingface bundle

    Scaffold a PhysicsIntern research workspace in the current folder. Run only when the user explicitly invokes it to set up a new physics/maths research workspace.
    10.8k repo stars
19. ▌
    Init Physics Intern 4 · huggingface

    Scaffold a PhysicsIntern research workspace in the current folder.
    10.8k repo stars
20. ▌
    Hf Mem 2 · huggingface

    Hugging Face CLI to estimate the required memory to load Safetensors or GGUF model weights for inference from the Hugging Face Hub
    10.8k repo stars
21. ▌
    Huggingface Best 2 · huggingface

    Use when the user asks about finding the best, top, or recommended model for a task, wants to know what AI model to use, or wants to compare models by benchmark scores. Triggers on: "best model for X", "what model should I use for", "top models for [task]", "which model runs on my laptop/machine/device", "recommend a model for", "what LLM should I use for", "compare models for", "what's state of the art for", or any question about choosing an AI model for a specific use case. Always use this skill when the user wants model recommendations or comparisons, even if they don't explicitly mention HuggingFace or benchmarks.
    10.8k repo stars
22. ▌
    Huggingface Spaces 2 · huggingface bundle

    Build, deploy, and maintain applications on Hugging Face Spaces — Gradio / Docker / Static SDKs, ZeroGPU and dedicated hardware, model loading, debugging, buckets, inference providers, community grants. Use whenever the user asks to create or host an app on Hugging Face, port code onto ZeroGPU, fix a Space that won't build or run, or otherwise work with `hf spaces …`, `@spaces.GPU`, Space README frontmatter, or the `spaces` Python package.
    10.8k repo stars
23. ▌
    Huggingface Zerogpu 2 · huggingface bundle

    AI demos and GPU compute with Gradio Spaces and Hugging Face Spaces ZeroGPU. Use when writing or reviewing code that uses `@spaces.GPU`, configuring `python_version` or `requirements.txt` for a ZeroGPU Space, or handling ZeroGPU-specific code constraints — pickle-based process isolation, `gr.State` semantics across the worker boundary, no `torch.compile` (use AoTI instead), CUDA wheel-only builds (no `nvcc` at build or runtime), large vs xlarge sizing, and dynamic duration callables. Make sure to use this skill whenever the user mentions ZeroGPU, `@spaces.GPU`, or the `spaces` Python package, or hits ZeroGPU-specific code errors like `PicklingError` across the worker boundary, `illegal duration`, or `flash-attn` wheel-build failures — even when the user does not explicitly ask for ZeroGPU coding guidance. Trigger on `import spaces` or `@spaces.GPU` in code.
    10.8k repo stars
24. ▌
    Huggingface Local Models 2 · huggingface bundle

    Use to select models to run locally with llama.cpp and GGUF on CPU, Mac Metal, CUDA, or ROCm. Covers finding GGUFs, quant selection, running servers, exact GGUF file lookup, conversion, and OpenAI-compatible local serving.
    10.8k repo stars
25. ▌
    Init Physics Intern 2 · huggingface

    Scaffold a PhysicsIntern research workspace in the current folder.
    10.8k repo stars
26. ▌
    Sync Models · huggingface

    Sync chat-ui's model config with the HuggingFace router — add descriptions for new models, flag reasoning-capable ones, enable artifacts for models with 32B+ parameters, and prune deprecated models the router no longer serves. Use when models are released or removed on the router and prod.yaml/dev.yaml need syncing. Triggers on requests like "add new model descriptions", "update models from router", "sync models", "remove deprecated models", "prune models no longer on the router", or when explicitly invoking /sync-models.
    10.8k repo stars
27. ▌
    Hugging Face Evaluation · huggingface bundle

    Add evaluation results to Hugging Face model repositories using the .eval_results/ format. Uses HF CLI for PR management and manual YAML creation.
    10.8k repo stars
28. ▌
    Hf Release Notes · huggingface bundle

    Generate Hugging Face Hub (huggingface_hub) release notes from cached PR JSON files. Use when asked to draft release notes from PR files.
    10.8k repo stars
29. ▌
    Peft Method Changes · huggingface

    Use when modifying an existing PEFT method (its forward method, parameters/buffers, state_dict handling, or config defaults) to ensure that existing checkpoints keep working.
    10.8k repo stars
30. ▌
    Init Physics Intern · huggingface

    Scaffold a PhysicsIntern research workspace in the current folder.
    10.8k repo stars
31. ▌
    Transformers To Mlx · huggingface bundle

    Convert Hugging Face transformers language models to MLX format for Apple Silicon inference. Use when asked to convert a model from transformers to MLX, port a model to MLX, create an MLX implementation of a model, or test/validate an MLX model conversion. Triggers include mentions of "convert to MLX", "MLX implementation", "port to MLX", "mlx-lm", or requests involving both transformers and MLX frameworks.
    10.8k repo stars
32. ▌
    Harbor Hf · huggingface

    Submit, monitor, pause, resume, cancel, and inspect Harbor benchmark runs through the hosted Harbor-HF control service and Hugging Face Jobs.
    10.8k repo stars
33. ▌
    Project Authorization · huggingface

    Ask for project approval before starting repository work, record the approved scope in the control-plane project file indexed by canonical repository slug, and recover authorization after compaction or session changes. Use before implementing, deploying, publishing, merging, spending, moving credentials, cutting over, or retiring resources for a repository.
    10.8k repo stars
34. ▌
    Tiny Model Creator · huggingface

    Create a small random Hugging Face model that preserves the original architecture and can serve as a local Optimum Intel repository test fixture.
    10.8k repo stars
35. ▌
    Optimum Model Enabler · huggingface bundle

    Add and validate support for a Hugging Face model architecture in the Optimum Intel OpenVINO backend, including exporter configuration, patching, repository tests, and documentation.
    10.8k repo stars
36. ▌
    Investigate Run · huggingface

    Investigates PhysicsIntern workspace run. Use to understand what went wrong and could be improved in the multi-agent research process.
    10.8k repo stars
37. ▌
    Investigate Autophysicist Run · huggingface

    Investigates an Autophysicist workspace run. Use to understand what went wrong and could be improved in the single-agent iterative research process.
    10.8k repo stars
38. ▌
    Mlclaw · huggingface bundle

    Use when setting up, operating, migrating, repairing, or explaining an OpenClaw deployment on Hugging Face with the ML Claw `mlclaw` CLI. Covers the browser Space gateway, Hugging Face OAuth, local gateway mode, private Storage Buckets, Telegram as an optional connector, Docker context pinning, model selection through the Hugging Face Router, OpenAI API key setup, costs, diagnostics, and state safety.
    10.8k repo stars
39. ▌
    Hf Broker · huggingface

    Use ML Claw's HF Broker for protected Hugging Face repository and bucket reads, writes, temporary grants, recovery, and revocation. Use instead of asking for or exposing a Hugging Face access token.
    10.8k repo stars
40. ▌
    Toml Config · huggingface

    How to write and use TOML configs in prime-rl. Use when creating config files, running commands with configs, or overriding config values via CLI.
    10.8k repo stars
41. ▌
    Installation · huggingface

    How to install prime-rl and its optional dependencies. Use when setting up the project, installing extras like deep-gemm for FP8 models, or troubleshooting dependency issues.
    10.8k repo stars
42. ▌
    Inference Server · huggingface

    Start and test the prime-rl inference server. Use when asked to run inference, start vLLM, test a model, or launch the inference server.
    10.8k repo stars
43. ▌
    Add Mlinter Rule · huggingface

    Add a new TRF rule to the mlinter. Checks for duplicates, creates the rule module and TOML entry, runs against all models, and handles violations (fix or allowlist).
    10.8k repo stars
44. ▌
    Remove Mlinter Rule · huggingface

    Retire a TRF rule from the mlinter. Marks the rule deprecated in rules.toml, deletes its module and tests, and records the removal in the CHANGELOG. Use when asked to remove, retire, drop, or delete a rule.
    10.8k repo stars
45. ▌
    Cpu Kernels · huggingface bundle

    Provides guidance for writing, optimizing, and benchmarking C++ CPU kernels with SIMD intrinsics (AVX2/AVX512) for the Hugging Face kernels ecosystem. Includes a two-phase workflow: Phase 1 correctness (generic → AVX2) and Phase 2 performance exploration (AVX512 with branching trial loop), runtime CPU dispatch, OpenMP threading, and brgemm integration for GEMM-heavy kernels.
    10.8k repo stars
46. ▌
    Xpu Kernels · huggingface bundle

    Provides guidance for writing, optimizing, and benchmarking Triton kernels for Intel XPU GPUs (Battlemage/Arc Pro B50) using the Xe-Forge optimization framework. Includes an LLM-driven trial-loop workflow (analyze, validate, benchmark, profile, finalize), XPU-specific patterns (tensor descriptors, GRF mode, tile swizzling), KernelBench fused kernels, and Flash Attention.
    10.8k repo stars
47. ▌
    Cuda Kernels · huggingface bundle

    Provides guidance for writing and benchmarking optimized CUDA kernels for NVIDIA GPUs (H100, A100, T4) targeting HuggingFace diffusers and transformers libraries. Kernels must be kernel-builder/ABI3-compliant: no pybind11, no setup.py, TORCH_LIBRARY_EXPAND bindings only. Supports models like LTX-Video, Stable Diffusion, LLaMA, Mistral, and Qwen. Includes integration with HuggingFace Kernels Hub (get_kernel) for loading pre-compiled kernels. Includes benchmarking scripts to compare kernel performance against baseline implementations.
    10.8k repo stars
48. ▌
    Rocm Kernels · huggingface bundle

    Provides guidance for writing and benchmarking optimized Triton kernels for AMD GPUs (MI355X, R9700) on ROCm, targeting HuggingFace diffusers (LTX-Video, SD3, FLUX) and transformers. Core kernels: RMSNorm, RoPE 3D, GEGLU, AdaLN. Includes XCD swizzle, autotune, diffusers integration patterns, and LTX-Video pipeline injection.
    10.8k repo stars
49. ▌
    Triton Kernels · huggingface bundle

    | name | triton-kernels |
    10.8k repo stars
50. ▌
    Sprint · huggingface

    Work on a batch of GitHub issues in parallel using Agent Teams. Creates one worktree per issue with TDD enforcement, coordinates via a lead agent, then produces stacked PRs.
    10.8k repo stars
51. ▌
    Release · huggingface

    Release workflow for deploying OpenEnv environments to Hugging Face Spaces and keeping canonical references in sync.
    10.8k repo stars
52. ▌
    Simplify · huggingface

    Refactor code after tests pass. The "Refactor" phase of Red-Green-Refactor.
    10.8k repo stars
53. ▌
    Watch Pr · huggingface

    Monitor a PR's CI checks and Greptile code review after submission. Polls CI status, auto-fixes failures via ralph-loop, waits for Greptile review, addresses comments, and iterates until green.
    10.8k repo stars
54. ▌
    Deploy Hf · huggingface

    Deploy an OpenEnv environment to Hugging Face Spaces. Use when asked to deploy, push to Hugging Face, or update a space.
    10.8k repo stars
55. ▌
    Implement · huggingface

    Make tests pass. Invoke after /write-tests produces failing tests.
    10.8k repo stars
56. ▌
    Rfc Check · huggingface

    Determine if proposed changes require an RFC. Use when planning significant changes, before starting major work, or when asked whether an RFC is needed.
    10.8k repo stars
57. ▌
    Openenv CLI · huggingface

    OpenEnv CLI (`openenv`) for scaffolding, validating, building, and pushing OpenEnv environments.
    10.8k repo stars
58. ▌
    Update Docs · huggingface

    Update documentation across the repo after API changes. Finds stale references in docs, examples, docstrings, and fixes them.
    10.8k repo stars
59. ▌
    Write Tests · huggingface

    Write failing tests from requirements. Invoke for each todo before /implement.
    10.8k repo stars
60. ▌
    Pre Submit Pr · huggingface

    Validate changes before submitting a pull request. Run comprehensive checks including lint, tests, alignment review, and RFC analysis. Use before creating a PR, when asked if code is ready for review, or before pushing for PR.
    10.8k repo stars
61. ▌
    Work On Issue · huggingface

    Start work on a GitHub issue. Extracts requirements, creates worktree, sets up TDD workflow.
    10.8k repo stars
62. ▌
    Alignment Review · huggingface

    Review code changes for bugs and alignment with OpenEnv principles and RFCs. Use when reviewing PRs, checking code before commit, or when asked to review changes. Implements two-tier review model.
    10.8k repo stars
63. ▌
    Hf Space Recovery · huggingface bundle

    Diagnose and recover failing or stuck Hugging Face Space deployments for OpenEnv environments. Use when deploying envs from `envs/` to the Hub (`openenv` namespace with version suffixes), when Spaces are in `BUILDING`/`APP_STARTING`/`RUNTIME_ERROR`, or when release collections need to be reconciled after targeted redeploys.
    10.8k repo stars
64. ▌
    Generate Openenv Env · huggingface bundle

    Generate OpenEnv environments from a concrete use case (for example, "generate an env for the library textarena"). Use when asked to design or implement a new environment under envs/ by researching a target library/API, selecting matching OpenEnv examples, asking key implementation questions, and building models/client/server/openenv.yaml. Do not use for model training or evaluation tasks.
    10.8k repo stars
65. ▌
    Update Conferences · huggingface

    Prioritize and run Modal conference-deadline agents on high-ROI conferences only. Use when updating conference YAML via agents/modal_agent.py, choosing which conferences to refresh, running deadline agents, or avoiding expensive all-conference Modal runs.
    10.8k repo stars
66. ▌
    Update Paper Index · huggingface

    Add or review a paper entry in TRL's paper index. Use when a PR implements a method, algorithm, or training approach from a research paper, or when reviewing such a PR.
    10.8k repo stars
67. ▌
    Self Review · huggingface

    Use before opening a PR, or whenever asked to self-review a diffusers contribution. Applies the same rubric as the `@claude` CI (checks the diff against references/review-rules.md, traces call paths for dead code). Reports findings grouped by severity, flagging what to fix before submitting (blocking issues + dead code) vs what to leave for the actual review. Report-only — does not edit files.
    10.8k repo stars
68. ▌
    Custom Blocks · huggingface

    Use when the user has written (or wants to write) a `ModularPipelineBlocks` subclass in a local Python file and needs to package it into a Hub-uploadable directory. Covers the workflow from a single `block.py` file to a published custom-block repo that consumers can load via `ModularPipeline.from_pretrained(<repo>, trust_remote_code=True)`.
    10.8k repo stars
69. ▌
    Diffusers CLI · huggingface bundle

    Use when the user wants to run a diffusers pipeline from a terminal (one-off generation, batch jobs, smoke-testing a new model), run on HF Sandbox hardware via `--remote`, introspect a pipeline's input schema before calling it, or attach a LoRA at inference time. Prefer this over writing ad-hoc Python scripts for generation tasks.
    10.8k repo stars
70. ▌
    Model Integration · huggingface

    Use when adding a new model or pipeline to diffusers, setting up file structure for a new model, converting a pipeline to modular format, or converting weights for a new version of an already-supported model.
    10.8k repo stars
71. ▌
    Hugging Face Dataset Viewer · huggingface

    Hugging Face Dataset Viewer
    10.8k repo stars
72. ▌
    Hugging Face Community Evals · huggingface bundle

    Run evaluations for Hugging Face Hub models using inspect-ai and lighteval on local hardware. Use for backend selection, local GPU evals, and choosing between vLLM / Transformers / accelerate.
    10.8k repo stars
73. ▌
    Hugging Face Gradio · huggingface bundle

    Build Gradio web UIs and demos in Python. Use when creating or editing Gradio apps, components, event listeners, layouts, or chatbots.
    10.8k repo stars
74. ▌
    Hugging Face Papers · huggingface

    Look up and read Hugging Face paper pages in markdown, and use the papers API for structured metadata such as authors, linked models/datasets/spaces, Github repo and project page.
    10.8k repo stars
75. ▌
    Hugging Face Trackio · huggingface bundle

    Track and visualize ML training experiments with Trackio. Use when logging metrics during training (Python API), firing alerts for training diagnostics, or retrieving/analyzing logged metrics (CLI).
    10.8k repo stars
76. ▌
    Hugging Face Model Trainer · huggingface bundle

    Train or fine-tune language and vision models using TRL (Transformer Reinforcement Learning) or Unsloth with Hugging Face Jobs infrastructure. Covers SFT, DPO, GRPO and reward modeling training methods, plus GGUF conversion for local deployment.
    10.8k repo stars
77. ▌
    Hugging Face Vision Trainer · huggingface bundle

    Train object detection, image classification, and SAM or SAM2 segmentation models locally or on Hugging Face Jobs, with dataset validation and results saved to the Hub.
    10.8k repo stars
78. ▌
    Hugging Face Paper Publisher · huggingface bundle

    Publish and manage research papers on Hugging Face Hub. Supports creating paper pages, linking papers to models/datasets, claiming authorship, and generating professional markdown-based research articles.
    10.8k repo stars
79. ▌
    Hugging Face Jobs · huggingface bundle

    Run workloads on Hugging Face Jobs with managed CPUs, GPUs, TPUs, secrets, and Hub persistence.
    10.8k repo stars
80. ▌
    Hugging Face CLI · huggingface

    Hugging Face Hub CLI (`hf`) for downloading, uploading, and managing models, datasets, spaces, buckets, repos, papers, jobs, and more on the Hugging Face Hub.
    10.8k repo stars
81. ▌
    Hf Cloud Python Env Setup · huggingface bundle

    Sets up an isolated Python environment for SageMaker and AWS work, pinning Python version and installing current boto3/awscli to avoid dependency conflicts and stale SDKs.
    10.8k repo stars
82. ▌
    Hf Cloud AWS Context Discovery · huggingface

    Reads the local AWS configuration to determine the active profile, region, account ID, and caller identity before any AWS task, avoiding guesswork and preventing common deployment errors.
    10.8k repo stars
83. ▌
    Hf Cloud Sagemaker Iam Preflight · huggingface bundle

    Discovers, validates, or creates a SageMaker execution role before deploying or training, preventing IAM-related deployment failures.
    10.8k repo stars
84. ▌
    Hf Cloud Serving Image Selection · huggingface bundle

    Selects the correct SageMaker serving container image URI for HuggingFace model deployments, prioritizing HuggingFace-curated Deep Learning Containers over generic alternatives.
    10.8k repo stars
85. ▌
    Hf Cloud Sagemaker Deployment Planner · huggingface

    Plans and coordinates the deployment of a model to Amazon SageMaker AI, selecting the appropriate pathway (real-time, serverless, async, batch, or Bedrock CMI) based on model type, traffic, latency, and cost constraints.
    10.8k repo stars
86. ▌
    Hf Cloud Sagemaker Production Defaults · huggingface bundle

    Creates SageMaker endpoints (real-time or async) with autoscaling, CloudWatch alarms, and tagging enabled by default, then smoke-tests them before declaring success.
    10.8k repo stars
87. ▌
    Hf CLI · huggingface

    Manage Hugging Face Hub resources: download/upload models, datasets, spaces; manage repos, buckets, collections, discussions, and cache; run SQL queries on datasets; authenticate and manage tokens.
    10.8k repo stars
88. ▌
    Hf Mem · huggingface

    Estimates the memory required to load Safetensors or GGUF model weights for inference from the Hugging Face Hub, using HTTP Range requests without downloading weights.
    10.8k repo stars
89. ▌
    Trl Training · huggingface

    Train and fine-tune transformer language models using TRL (Transformers Reinforcement Learning) with support for SFT, DPO, GRPO, KTO, RLOO, and reward model training via CLI commands.
    10.8k repo stars
90. ▌
    Hf MCP · huggingface

    Search models, datasets, Spaces, and papers on the Hugging Face Hub, retrieve repository details and documentation, run compute jobs, and use Gradio Spaces as AI tools via the Hugging Face MCP server.
    10.8k repo stars
91. ▌
    Transformers JS · huggingface bundle

    Run state-of-the-art machine learning models directly in JavaScript/TypeScript across browsers and server-side runtimes using Transformers.js.
    10.8k repo stars
92. ▌
    Huggingface Best · huggingface

    Queries Hugging Face benchmark leaderboards to find the best AI models for a task, filters by device constraints, and returns a ranked comparison table with scores.
    10.8k repo stars
93. ▌
    Huggingface Gradio · huggingface bundle

    Build interactive web UIs and ML demos in Python using Gradio's core API, components, and patterns.
    10.8k repo stars
94. ▌
    Huggingface Papers · huggingface

    Look up and read Hugging Face paper pages in markdown, and use the papers API for structured metadata such as authors, linked models/datasets/spaces, Github repo and project page.
    10.8k repo stars
95. ▌
    Huggingface Spaces · huggingface bundle

    Create, deploy, and debug machine learning applications on Hugging Face Spaces using Gradio, Docker, or Static SDKs, with support for ZeroGPU and dedicated hardware.
    10.8k repo stars
96. ▌
    Huggingface Trackio · huggingface bundle

    Track and visualize ML training experiments with Trackio, including logging metrics, firing alerts, and retrieving data via CLI. Supports real-time dashboards, webhook alerts, and HF Space syncing.
    10.8k repo stars
97. ▌
    Huggingface Zerogpu · huggingface bundle

    Build ML demos on Hugging Face Spaces with ZeroGPU hardware, covering @spaces.GPU decorator usage, duration and quota tuning, process isolation, CUDA availability model, concurrency safety, and build constraints.
    10.8k repo stars
98. ▌
    Huggingface Datasets · huggingface

    Fetch dataset metadata, paginate rows, search text, apply filters, and download parquet URLs from the Hugging Face Dataset Viewer API.
    10.8k repo stars
99. ▌
    Huggingface LLM Trainer · huggingface bundle

    Train or fine-tune language and vision models using TRL or Unsloth on Hugging Face Jobs cloud infrastructure, with support for SFT, DPO, GRPO, and reward modeling, plus GGUF conversion for local deployment.
    10.8k repo stars
100. ▌
     Huggingface Local Models · huggingface bundle

     Search the Hugging Face Hub for llama.cpp-compatible GGUF models, select the right quantization, and run them locally with llama-cli or llama-server.
     10.8k repo stars