hugging-face-tool-builder
Helps your agent create reusable scripts and utilities for the Hugging Face API. It allows chaining commands and processing intermediate data.
What it does
This agent creates command-line scripts to use the Hugging Face API. It helps automate repetitive tasks and combine different tools.
When to use it
- ✓When you need to create scripts to fetch model information from Hugging Face.
- ✓To automate downloading files from Hugging Face repositories.
- ✓When wanting to combine multiple Hugging Face API calls into a single process.
Example of what to ask your AI
“Create a script that lists the top 10 most downloaded models on Hugging Face and saves their names to a file.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
It uses the `hf` command-line tool or makes direct calls to the Hugging Face API. The created scripts can be chained together to process data in steps.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add sickn33/agentic-awesome-skills --skill hugging-face-tool-builderOr download just the file:
curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/plugins/agentic-awesome-skills-claude/skills/hugging-face-tool-builder/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Supporting material availability
This catalog copy contains the inline guidance below, but does not include the following supporting paths. They are external prerequisites, not bundled files:
<support-root>/references/hf_model_papers_auth.sh<support-root>/references/find_models_by_paper.sh<support-root>/references/hf_model_card_frontmatter.sh<support-root>/references/baseline_hf_api.sh<support-root>/references/baseline_hf_api.py<support-root>/references/baseline_hf_api.tsx<support-root>/references/hf_enrich_models.sh
Ask for the original supporting material or an existing installation before using a step that depends on these paths; this catalog does not identify a verified download source for them. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.
Hugging Face API Tool Builder
Your purpose is now is to create reusable command line scripts and utilities for using the Hugging Face API, allowing chaining, piping and intermediate processing where helpful. You can access the API directly, as well as use the hf command line tool. Model and Dataset cards can be accessed from repositories directly.
When to Use
- You need reusable CLI scripts around the Hugging Face API or
hfcommand line tool. - You want shell-friendly utilities that support chaining, piping, and intermediate processing.
- You are automating repeated Hub tasks and need a composable interface instead of ad hoc API calls.
Script Rules
Make sure to follow these rules:
- Scripts must take a
--helpcommand line argument to describe their inputs and outputs - Non-destructive scripts should be tested before handing over to the User
- Shell scripts are preferred, but use Python or TSX if complexity or user need requires it.
- IMPORTANT: Use the
HF_TOKENenvironment variable as an Authorization header. For example:curl -H "Authorization: Bearer ${HF_TOKEN}" https://huggingface.co/api/. This provides higher rate limits and appropriate authorization for data access. - Investigate the shape of the API results before commiting to a final design; make use of piping and chaining where composability would be an advantage - prefer simple solutions where possible.
- Share usage examples once complete.
Be sure to confirm User preferences where there are questions or clarifications needed.
Sample Scripts
Paths below are relative to this skill directory.
Reference examples:
references/hf_model_papers_auth.sh— usesHF_TOKENautomatically and chains trending → model metadata → model card parsing with fallbacks; it demonstrates multi-step API usage plus auth hygiene for gated/private content.references/find_models_by_paper.sh— optionalHF_TOKENusage via--token, consistent authenticated search, and a retry path when arXiv-prefixed searches are too narrow; it shows resilient query strategy and clear user-facing help.references/hf_model_card_frontmatter.sh— uses thehfCLI to download model cards, extracts YAML frontmatter, and emits NDJSON summaries (license, pipeline tag, tags, gated prompt flag) for easy filtering.
Baseline examples (ultra-simple, minimal logic, raw JSON output with HF_TOKEN header):
references/baseline_hf_api.sh— bashreferences/baseline_hf_api.py— pythonreferences/baseline_hf_api.tsx— typescript executable
Composable utility (stdin → NDJSON):
references/hf_enrich_models.sh— reads model IDs from stdin, fetches metadata per ID, emits one JSON object per line for streaming pipelines.
Composability through piping (shell-friendly JSON output):
<support-root>/references/baseline_hf_api.sh 25 | jq -r '.[].id' | references/hf_enrich_models.sh | jq -s 'sort_by(.downloads) | reverse | .[:10]'<support-root>/references/baseline_hf_api.sh 50 | jq '[.[] | {id, downloads}] | sort_by(.downloads) | reverse | .[:10]'printf '%s\n' openai/gpt-oss-120b meta-llama/Meta-Llama-3.1-8B | references/hf_model_card_frontmatter.sh | jq -s 'map({id, license, has_extra_gated_prompt})'
High Level Endpoints
…
FAQ
What is the Hugging Face API?
It's a set of commands that allows computer programs to interact with Hugging Face resources, like models and datasets.
What does 'command line' mean?
It's a way to interact with the computer by typing commands into a program called a terminal or command prompt, rather than using a mouse and icons.
What is `jq`?
`jq` is a tool that helps read and organize data in JSON format, which is how the Hugging Face API returns a lot of information.
Details
Original description by the author
Your purpose is now is to create reusable command line scripts and utilities for using the Hugging Face API, allowing chaining, piping and intermediate processing where helpful. You can access the API directly, as well as use the hf command line tool.
Popularity
- GitHub stars
- 48k
- Ranking position
- #3228
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
00-andruia-consultant
Helps your agent start or improve AI projects. It analyzes code, suggests tools, and creates action plans in Spanish.
sickn33/agentic-awesome-skills
007
Lets your agent perform security audits and threat modeling. It's useful for protecting projects against attacks and vulnerabilities.
sickn33/agentic-awesome-skills
10-andruia-skill-smith
Helps your agent create or improve AI tools. It defines how tools work, writes documentation, and validates the structure.
sickn33/agentic-awesome-skills
20-andruia-niche-intelligence
Lets your agent create a summary about a specific industry. It's useful for understanding the context, rules, usage patterns, and risks of a project, using reliable sources.
sickn33/agentic-awesome-skills
Similar skills
benchmark-optimization-loop
Has your agent improve something's speed in a measured way. It tests multiple versions and chooses the fastest one that still works correctly.
affaan-m/ECC
change-impact
Helps your agent analyze the impact of code changes before making them. It compares the planned vs. actual results afterward, covering paths, data, tests, and documentation. Useful for risky or system-wide changes.
affaan-m/ECC
click-path-audit
Lets your agent trace all user buttons and interactions to find bugs. It finds issues where functions seem to work alone but fail together. Useful when bugs persist even after debugging.
affaan-m/ECC