### Quick Start: Install and Manage Skills

Source: https://pypi.org/project/skillsctl

A quick guide to setting up the catalog source, searching for skills, installing a skill, and managing installed items. This covers common initial use cases.

```bash
# Point at your org's catalog
export SKILLSCTL_SOURCE=https://catalog.your-company.com

# Search for available items
skillsctl search slack

# Install a skill (its dependencies come along too)
skillsctl install send-slack-notification

# Install into a custom directory (flat, no category subfolder)
skillsctl install my-rule --path .claude/commands

# Set a project-wide default output directory
skillsctl config base-dir .claude     # → .claude/skills/… .claude/agents/… etc.
skillsctl config base-dir .windsurf   # → .windsurf/rules/… .windsurf/agents/… etc.
skillsctl config base-dir --unset     # reset to .skillsctl (default)

# List what's installed
skillsctl list

# Update everything to latest
skillsctl sync
```

--------------------------------

### Install Sample Skills

Source: https://pypi.org/project/skills-as-mcp

Install sample skills from GitHub URLs after starting the server. These examples demonstrate installing web search, code reviewer, and daily standup skills.

```bash
# Start the server
skills-as-mcp

# Then from any MCP client, install a sample skill:
install_skill(url="https://raw.githubusercontent.com/sumododda/skills-as-mcp/main/examples/web-search/SKILL.md")
install_skill(url="https://raw.githubusercontent.com/sumododda/skills-as-mcp/main/examples/code-reviewer/SKILL.md")
install_skill(url="https://raw.githubusercontent.com/sumododda/skills-as-mcp/main/examples/daily-standup/SKILL.md")
```

--------------------------------

### Run Setup Wizard

Source: https://pypi.org/project/skill-seekers

Launch the interactive setup wizard for skill-seekers to help choose installation options.

```bash
skill-seekers-setup
```

--------------------------------

### Quick Start: Clone and Install

Source: https://pypi.org/project/skillbench

Clone the SkillBench repository, set up a virtual environment, and install the package locally.

```bash
git clone https://github.com/YOUR_USERNAME/skillbench.git
cd skillbench
python3 -m venv .venv && source .venv/bin/activate
pip install .
```

--------------------------------

### Install Sample Skill

Source: https://pypi.org/project/skills-as-mcp

Example of how to install a sample skill using the `install_skill` tool.

```APIDOC
## Examples

Install a sample skill from the repo:
```
# Start the server
skills-as-mcp

# Then from any MCP client, install a sample skill:
install_skill(url="https://raw.githubusercontent.com/sumododda/skills-as-mcp/main/examples/web-search/SKILL.md")
install_skill(url="https://raw.githubusercontent.com/sumododda/skills-as-mcp/main/examples/code-reviewer/SKILL.md")
install_skill(url="https://raw.githubusercontent.com/sumododda/skills-as-mcp/main/examples/daily-standup/SKILL.md")
```

Or install from a local file:
```
install_skill(content=open("examples/web-search/SKILL.md").read())
```
```

--------------------------------

### Quick Start: Install and manage skills

Source: https://pypi.org/project/skill-trivium

Common commands for installing, managing environments, and listing skills.

```bash
# Install skills from a git repository
trv add https://github.com/example/skills.git --all

# Install specific skills
trv add https://github.com/example/skills.git --skills pdf-processing algorithmic-art

# Capture the current runtime as an environment
trv env create office

# Activate a named environment
trv env activate office

# List installed skills
trv list

# Update installed skills
trv update

# Create a new skill scaffold
trv init my-skill

```

--------------------------------

### SkillScope CLI Quick Start Commands

Source: https://pypi.org/project/skillscope

Examples of common SkillScope CLI commands for quick usage. These cover recommending skills, searching, viewing details, and installing.

```bash
skillscope recommend "translate a PDF document to Chinese"

```

```bash
skillscope recommend "write unit tests" --region cn --budget free --platform macos

```

```bash
skillscope search "web scraping"

```

```bash
skillscope detail steipete/weather

```

```bash
skillscope install steipete/weather

```

--------------------------------

### Session Management Example

Source: https://pypi.org/project/skill-optimizer

Example of starting a session with user and organization context.

```python
session = optimizer.start_session(user_id="user_123", org="acme-corp")
```

--------------------------------

### Quick Start: Setup Skill MCP Server

Source: https://pypi.org/project/skill-mcp-server

Set up the Skill MCP Server by creating a skills directory, copying a sample skill, and starting the server. This demonstrates the basic functionality.

```bash
# 1. Create a skills directory
mkdir skills

# 2. Download or create a skill (example: copy the skill-creator)
cp -r examples/skill-creator skills/

# 3. Start the server
skill-mcp-server --skills-dir ./skills

```

--------------------------------

### Development Setup

Source: https://pypi.org/project/skill-retrieval-mcp

Steps to clone the repository, install dependencies, and run tests for development.

```bash
git clone https://github.com/JayCheng113/skill-retrieval-mcp
cd skill-retrieval-mcp
pip install -e ".[all,dev]"
pytest tests/ -v    # 139 tests, ~0.7s
```

--------------------------------

### Install SkillMesh and Run Demo

Source: https://pypi.org/project/skillmesh

Clone the SkillMesh repository, install it, and run an example emit command.

```bash
git clone https://github.com/varunreddy/SkillMesh.git
cd SkillMesh
pip install -e .
skillmesh emit \
  --provider claude \
  --registry examples/registry/tools.json \
  --query "clean messy sales data, train a baseline model, and generate charts" \
  --top-k 5
```

--------------------------------

### Clone and Install skill-issues

Source: https://pypi.org/project/skill-issues

Clone the repository and install the project using uv. This is a common setup for development.

```bash
git clone https://github.com/davidcpage/skill-issues.git
cd skill-issues
uv tool install -e .
```

--------------------------------

### Quickstart: Indexing and Searching Agent Skills

Source: https://pypi.org/project/skill-tuple-space

A quickstart guide demonstrating the core functionalities of skill-tuple-space, including configuration, indexing, fuzzy and semantic search, Linda-style template matching, learning journal interactions, and space health checks.

```bash
# 1. Copy and edit config
mkdir -p ~/.skill-space
cp config.example.toml ~/.skill-space/config.toml

# 2. Index your repos
skill-space index run

# 3. Semantic + fuzzy search
skill-space search query "create something visual with 3d"

# 4. Linda-style template matching
skill-space search read "skill_class=Process, crud_verb=create, topic=*"

# 5. Learning journal
skill-space learn claim create-openscad-from-construction-image-en
skill-space learn done create-openscad-from-construction-image-en --level 4
skill-space learn next --topic agent-skills

# 6. Space health
skill-space space stats
skill-space space drift
```

--------------------------------

### SkillForge Setup Wizard Session

Source: https://pypi.org/project/skillforge

An example of the interactive SkillForge setup wizard session, including auto-detection of tech stack and user preference questions.

```text
╔════════════════════════════════════════════════╗
║  🧙 SkillForge Setup Wizard                    ║
║  Building YOUR personal development profile    ║
╚════════════════════════════════════════════════╝

🔍 Auto-detecting from current directory...
   /Users/you/projects/my-nextjs-app

✅ Detected:
   ├─ Next.js 15.0.0
   ├─ TypeScript 5.3
   ├─ Tailwind CSS
   └─ Supabase

Use these as defaults? [Y/n] Y

Great! Let me ask a few more questions about YOUR preferences...

1️⃣ YOUR naming convention for variables?
   [1] camelCase
   [2] snake_case
> 1

2️⃣ YOUR import style?
   [1] Absolute imports with alias (@/...)
   [2] Relative imports (../../...)
> 1

3️⃣ YOUR preferred state management?
   [1] Zustand
   [2] Redux Toolkit
   [3] Context API
> 1

... (8-10 more questions) ...

╔════════════════════════════════════════════════╗
║  ⚙️ Generating Skills...                       ║
╚════════════════════════════════════════════════╝

[1/3] 📦 Fetching Next.js documentation...
      └─ ✅ Documentation fetched (Context7)

[2/3] 🔨 Generating nextjs-fullstack skill...
      ├─ Processing template
      ├─ Injecting YOUR preferences
      ├─ Creating SKILL.md (2341 lines)
      └─ ✅ Skill generated

[3/3] 🔨 Generating supabase-integration skill...
      └─ ✅ Skill generated

✅ Setup Complete!

Skills installed:
  ~/.claude/skills/
  ├─ nextjs-fullstack/
  ├─ supabase-integration/
  └─ git-workflow/

Your skills will improve as you use them!
```

--------------------------------

### Install skillforge-cli

Source: https://pypi.org/project/skillforge-cli

Install the CLI tool using pip or pipx. After installation, set your API key and start a learning session.

```bash
pip install skillforge-cli
# or
pipx install skillforge-cli
```

```bash
export ANTHROPIC_API_KEY=sk-ant-...
skillforge learn "python basics"
```

--------------------------------

### Initial Skill Lab Run

Source: https://pypi.org/project/skill-lab

Run Skill Lab for the first time after installation. This command scans the repository and displays the getting started guide.

```bash
sklab
```

--------------------------------

### Quick Start: Create, Validate, Search, and Install Skills

Source: https://pypi.org/project/skill

Demonstrates the basic workflow of using the skill package: creating a new skill, validating its structure, searching for existing skills, and installing a skill for an agent.

```python
from skill import search, create, install, validate

# Create a skill locally
skill = create('my-skill', description='My custom coding rules')

# Validate it
issues = validate('/path/to/skill-dir')

# Search for skills
results = search('react best practices', local_only=True)

# Install to an agent target
install('_local/my-skill', agent_targets=['claude-code'], scope='project')
```

--------------------------------

### Development Setup

Source: https://pypi.org/project/skillsible

Commands for setting up the development environment, including syncing dependencies and running tests. Also includes examples for validating and planning with local configurations.

```bash
uv sync --dev
uv run pytest
uv run skillsible validate -f examples/stack.yml
uv run skillsible plan -f examples/skills.yml
```

--------------------------------

### Basic skillhub commands

Source: https://pypi.org/project/skillhub-cli

Examples of installing, searching, and publishing skills using the skillhub-cli.

```bash
skillhub install security-review
```

```bash
skillhub install pipe --platform cursor
```

```bash
skillhub search refactor
```

--------------------------------

### Initialize and Use Workspace

Source: https://pypi.org/project/skillfs

Quick start example demonstrating the initialization of an E2BSandbox and Workspace, loading previous state, running commands, and saving the workspace. Requires E2B and LLM API keys.

```python
import asyncio
from skillfs.workspaces import Workspace
from skillfs.sandboxes import E2BSandbox, SandboxConfig
from skillfs.storage import LocalBundleStore

async def main():
    sandbox = E2BSandbox.create(config=SandboxConfig(timeout=300))
    store = LocalBundleStore(directory="/tmp/workspaces")

    workspace = Workspace(
        workspace_id="my-workspace",
        sandbox=sandbox,
        store=store,
    )

    await workspace.load()  # Restore from previous session if exists

    # Use the sandbox directly
    sandbox.run_command("echo 'Hello, world!' > hello.txt")
    sandbox.run_command("cat hello.txt")

    workspace.save()  # Commit and upload git bundle
    sandbox.close()

asyncio.run(main())
```

--------------------------------

### Skillboard Development Setup

Source: https://pypi.org/project/skillboard

Commands for setting up the Skillboard project for development, including cloning the repository, creating a virtual environment, installing dependencies, and running tests.

```bash
# Clone the repository
git clone https://github.com/kriss-spy/skillboard.git
cd skillboard

# Create virtual environment
python -m venv .venv
source .venv/bin/activate

# Install in development mode
pip install -e ".[dev]"

# Run tests
pytest

# Format code
black skillboard/
ruff check --fix skillboard/

# Type check
mypy skillboard/

```

--------------------------------

### Verify Project Setup

Source: https://pypi.org/project/skillsops

Use these commands to verify your project setup, including Python dependencies, the store, registry, and IDE targets. The version command shows the current installed version.

```bash
skillctl doctor    # Python, deps, store, registry, IDE targets
```

```bash
skillctl version   # current version
```

--------------------------------

### Install skill-framework with UI support

Source: https://pypi.org/project/skill-framework

Use this command to install the library with local preview server capabilities. For a plain installation, use 'pip install skill-framework'.

```bash
pip install skill-framework[ui]
```

--------------------------------

### Development Setup and Testing

Source: https://pypi.org/project/skillens

Clone the SkiLens repository, set up a virtual environment, install development dependencies, and run tests. This is for contributing to SkiLens development.

```bash
git clone https://github.com/YixiaJack/skillens
cd skillens
python -m venv .venv && . .venv/Scripts/activate   # Windows
pip install -e ".[dev]"
pytest                                               # 67 tests, ~0.4s
```

--------------------------------

### SkillForge Development Setup

Source: https://pypi.org/project/skillforge

Instructions for setting up the SkillForge development environment. This includes cloning the repository, creating and activating a virtual environment, installing dependencies, and running tests and linters.

```bash
# Clone repository
git clone https://github.com/yourusername/skillforge.git
cd skillforge

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Run linter
ruff check .

```

--------------------------------

### Development Setup for skillforge-cli

Source: https://pypi.org/project/skillforge-cli

Clone the repository, set up a virtual environment, install dependencies in editable mode, and configure API keys for development.

```bash
git clone https://github.com/milank94/skillforge.git
cd skillforge
```

```bash
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

```bash
pip install --upgrade pip
pip install -e ".[dev]"
```

```bash
export ANTHROPIC_API_KEY=sk-ant-...
# or
export OPENAI_API_KEY=sk-...
```

```bash
skillforge --version
skillforge --help
```

--------------------------------

### Example Skill Setup and Secret Management

Source: https://pypi.org/project/skill-mcp

Illustrates the workflow for creating a skill, adding secrets to its .env file, and securing the file. This process ensures LLMs can use the skill without ever seeing the actual secret values.

```bash
# Step 1: Claude creates skill "api-client" via MCP
# You say: "Create a new skill called 'api-client'"

# Step 2: You manually secure the secrets
$ nano ~/.skill-mcp/skills/api-client/.env
API_KEY=sk-abc123def456xyz789
ENDPOINT=https://api.example.com

$ chmod 600 ~/.skill-mcp/skills/api-client/.env

# Step 3: Claude can now use the skill securely
# You say: "Run the API client script"
# Claude reads env var names only, uses them in scripts
# Your actual API key is never exposed to Claude
```

--------------------------------

### Clone and Setup Skill Fleet

Source: https://pypi.org/project/skill-fleet

Clone the Skill Fleet repository and install development dependencies using uv. This is the initial setup step before configuring the environment.

```bash
git clone https://github.com/qredence/skill-fleet.git
cd skill-fleet
uv sync --group dev

```

--------------------------------

### Start interactive skill management

Source: https://pypi.org/project/skills-hub

Launch the graphical interface for managing installed skills and agents.

```bash
skill manage
```

--------------------------------

### Skills Catalog Server Quick Start

Source: https://pypi.org/project/skillsctl

Commands to quickly set up and run a Skills Catalog Server using FastAPI. It includes installation of dependencies and running the server with a default port or by pointing to a specific Git repository for content.

```bash
# Quick start
pip install fastapi uvicorn python-frontmatter watchdog pydantic pydantic-settings jinja2 aiofiles markdown packaging
uvicorn catalog.main:app --port 8000

# Or point at your org's git repo
CATALOG_CONTENT_REPO=https://github.com/your-org/playbooks.git uvicorn catalog.main:app --port 8000


```

--------------------------------

### Setup Skillager with pip installation

Source: https://pypi.org/project/skillager

Run the Skillager setup command after installing it with pip. This command is used to configure Skillager for a specific agent.

```bash
python -m skillager setup --agent codex
```

--------------------------------

### Install Skill

Source: https://pypi.org/project/skillscan

The `install` command fetches, scans, and installs a skill in one step. It accepts a source (local path, URL) and options to override the target directory or force installation.

```bash
skillscan install <source> [options]
```

--------------------------------

### skillctl Installation Process Overview

Source: https://pypi.org/project/skillctl

Illustrates the installation process for a skill, showing the steps of cloning the repository, creating a symbolic link to the skills directory, and registering the skill in the manifest.

```bash
skillctl install anthropics/skills --path skills/pdf
         │
         ├─ git clone → ~/.skillctl/repos/anthropics__skills/
         ├─ symlink   → ~/.claude/skills/pdf → (clone)/skills/pdf
         └─ register  → ~/.skillctl/manifest.json
```

--------------------------------

### Skills Lockfile Example

Source: https://pypi.org/project/skillsctl

This is an example of the skills.yaml lockfile, which tracks catalog sources, configurations, and installed items with pinned versions. It can specify default paths or custom paths for installed items.

```yaml
source: https://catalog.your-company.com
base_dir: .claude                        # optional — set via `skillsctl config base-dir`
installed:
  http-request: "1.3.0"                 # default path — bare string
  send-slack-notification: "2.1.0"
  slack-ops-agent: "1.0.0"
  my-rule:                              # installed with --path
    version: "1.0.0"
    path: .claude/commands              # custom flat path stored here


```

--------------------------------

### Install skill-manager-treeshell

Source: https://pypi.org/project/skill-manager-treeshell

Install the package using pip. This command is used for initial setup.

```bash
pip install skill-manager-treeshell
```

--------------------------------

### Set Up Development Environment

Source: https://pypi.org/project/skillbench

Steps to clone the SkillBench repository, set up a virtual environment, and install development dependencies. This is for contributors wanting to work on the project.

```bash
git clone https://github.com/YOUR_USERNAME/skillbench.git
cd skillbench
python3 -m venv .venv && source .venv/bin/activate
pip install .[dev]
pytest tests/ -v
```

--------------------------------

### One-Time Development Setup

Source: https://pypi.org/project/skill-tagging

Clone the repository and set up a virtual environment for development.

```bash
# Clone the repository
git clone git@github.com:openedx/xblock-skill-tagging.git
cd xblock-skill-tagging

# Set up a virtualenv using virtualenvwrapper with the same name as the repo and activate it
mkvirtualenv -p python3.12 xblock-skill-tagging
```

--------------------------------

### Install SkillMesh MCP Server

Source: https://pypi.org/project/skillmesh

Install the necessary packages for the Claude MCP server and start the server.

```bash
pip install -e .[mcp]
skillmesh-mcp
```

--------------------------------

### Clone and Install Skills Hub

Source: https://pypi.org/project/skills-hub

Instructions for cloning the repository and installing the project locally. This sets up the development environment.

```bash
git clone https://github.com/youzaiAGI/agent-skills-hub.git
cd agent-skills-hub
pip install -e .

```

--------------------------------

### Development setup and commands

Source: https://pypi.org/project/skillup

Commands for setting up the development environment, running the CLI, and executing tests.

```bash
uv sync          # install deps
```

```bash
uv run skillup --help
```

```bash
uv run pytest
```

```bash
uv run pyright skillup
```

--------------------------------

### Install SkillScope CLI

Source: https://pypi.org/project/skillscope

Use pip to install the SkillScope CLI. This is the primary method for getting the tool.

```bash
pip install skillscope
```

--------------------------------

### Install Skill Lab

Source: https://pypi.org/project/skill-lab

Install the Skill Lab package using pip. This command is used for initial setup.

```bash
pip install skill-lab
```

--------------------------------

### Install skillctl

Source: https://pypi.org/project/skillctl

Install the skillctl package using pip. This is the first step to start managing agent skills.

```bash
pip install skillctl

```

--------------------------------

### Install skillsctl CLI

Source: https://pypi.org/project/skillsctl

Use pip to install the skillsctl command-line tool. This is the primary method for getting the tool onto your system.

```bash
pip install skillsctl
```

--------------------------------

### Set Up Development Environment

Source: https://pypi.org/project/skill-sentinel

Installs the project and its dependencies in a virtual environment. Ensure Python 3.13 is available.

```bash
uv venv --python 3.13 .venv
source .venv/bin/activate
uv pip install -e .
```

--------------------------------

### Example: Finding and Using a Skill

Source: https://pypi.org/project/skillhub

This example demonstrates the typical workflow of searching for a skill, viewing its details, downloading it, and then executing its content.

```bash
# 1. Search for what you need
$ skillhub search "benchmark model"

Found 2 skill(s)
┌─────────────────┬──────────────┬─────────────────────────────┬────────────────┐
│ Name            │ Category     │ Description                 │ Tags           │
├─────────────────┼──────────────┼─────────────────────────────┼────────────────┤
│ benchmark-qwen  │ benchmarking │ Benchmark Qwen 3B model...  │ llm, benchmark │
└─────────────────┴──────────────┴─────────────────────────────┴────────────────┘

# 2. Get more details
$ skillhub show benchmark-qwen

# 3. Pull the skill
$ skillhub pull benchmark-qwen

✓ Skill downloaded successfully!
Location: ./benchmark-qwen.md

# 4. Follow the steps in the file
$ cat benchmark-qwen.md
```

--------------------------------

### Install skillit with Development Dependencies

Source: https://pypi.org/project/skillit

Install the skillit package in editable mode with development dependencies. This is useful for contributing to the package or running examples.

```bash
pip install -e ".[dev]"
```

--------------------------------

### Install SkillMesh with MCP support

Source: https://pypi.org/project/skillmesh

Install the SkillMesh package with extra dependencies for MCP support. This is required if the 'skillmesh-mcp' command fails to start.

```bash
pip install -e .[mcp]
```

--------------------------------

### Manual installation of skill-installer

Source: https://pypi.org/project/skill-installer

Manual installation by cloning the repository, making the script executable, and creating a symbolic link.

```bash
git clone https://github.com/renekann/skill-installer.git
chmod +x skill-installer/skill_installer.py
ln -s "$PWD/skill-installer/skill_installer.py" /usr/local/bin/ski
```

--------------------------------

### Skillet SDK Quickstart

Source: https://pypi.org/project/skillet-sdk

A quickstart guide to using the Skillet SDK for building, exporting, evaluating, and refining packages. Requires an API key.

```python
from skillet import Client
client = Client(api_key="sk-...")
package = client.build("Your corpus text here...")

# Export to disk
package.bundle().extract_to("./my-skill")

# Evaluate
report = client.evaluate(package)

# Refine
result = client.refine(package, dev_tasks=[...], holdout_tasks=[...], edit_budget=3)
```

--------------------------------

### Create and Navigate Skill Project

Source: https://pypi.org/project/skill-engine-sdk

Initialize a new skill project using the `skill-sdk init` command and navigate into the project directory.

```bash
skill-sdk init my-awesome-skill
cd my-awesome-skill
```

--------------------------------

### Setup Video Visual Dependencies

Source: https://pypi.org/project/skill-seekers

After installing 'skill-seekers[video-full]', run this command to auto-detect your GPU and install the correct PyTorch variant and easyocr for visual extraction.

```bash
skill-seekers video --setup
```

--------------------------------

### Install SkillGate using pipx

Source: https://pypi.org/project/skillgate

Installs the SkillGate Python CLI using pipx for runtime execution. Use this command to get the canonical runtime version.

```bash
pipx install skillgate
skillgate --help

```

--------------------------------

### Install skill-retrieval-mcp with local and HF extras

Source: https://pypi.org/project/skill-retrieval-mcp

Install the skill-retrieval-mcp package with support for local and Hugging Face model backends. This is a common starting point for using the library.

```bash
pip install "skill-retrieval-mcp[local,hf]"
```

--------------------------------

### Library Read API Examples

Source: https://pypi.org/project/skill-mem

Examples of using the read methods of the Library class to route queries, retrieve skills by name, list all skills, and get utility or statistics.

```python
library.route(query, k=3) -> list[Match]       # hybrid search, top-k
library.get(name) -> Skill                     # full skill from disk
library.all() -> list[Skill]                   # everything
library.utility(name) -> float                 # success rate (0.0-1.0)
library.stats(name) -> Stats                   # utility, attempts, recent log
```

--------------------------------

### Install skillboard from source

Source: https://pypi.org/project/skillboard

Instructions for installing skillboard directly from its source code repository.

```bash
git clone https://github.com/kriss-spy/skillboard.git
cd skillboard
pip install -e .

```

--------------------------------

### Configuration File Example (.skill-readiness.toml)

Source: https://pypi.org/project/skill-readiness-analyzer

Example TOML configuration file for the skill-readiness-analyzer. Allows customization of scan timeouts, output formats, verbosity, heuristic limits, and failure severities.

```toml
[scan]
timeout_seconds = 30.0

[output]
format = "summary"
verbose = false

[heuristic]
max_lines = 500
max_tokens = 2000
min_description_length = 50

[fail]
severity = "high"

```

--------------------------------

### Start interactive skill search

Source: https://pypi.org/project/skills-hub

Initiate the interactive TUI search for discovering and installing skills.

```bash
skill search
```

--------------------------------

### Quick Start: Set API Keys and Scan

Source: https://pypi.org/project/skill-sentinel

Begin scanning Agent Skill packages by exporting your OpenAI API key and optionally your VirusTotal API key. Then, run the scan command on a specified directory.

```bash
# 1. Export your OpenAI API key
export OPENAI_API_KEY="sk-..."

# 2. (Optional) Export your VirusTotal API key for binary malware scanning
export VIRUSTOTAL_API_KEY="your-vt-api-key"

# 3. Scan a skill directory
skill-sentinel scan /path/to/skill/directory
```

--------------------------------

### Initialize Skillcorner Client and Get Teams

Source: https://pypi.org/project/skillcorner

This example demonstrates how to initialize the SkillcornerClient with your username and password, and then retrieve a list of teams.

```python
from skillcorner.client import SkillcornerClient

client = SkillcornerClient(username=<SKILLCORNER_USERNAME>, password=<SKILLCORNER_PASSWORD>)

teams = client.get_teams()


```

--------------------------------

### Install Skills from Different Sources

Source: https://pypi.org/project/skillsmd

Demonstrates various ways to specify the source of skills to install, including GitHub shorthand, full URLs, GitLab, any git URL, and local paths.

```bash
# GitHub shorthand (owner/repo)
uvx skillsmd add vercel-labs/agent-skills

# Full GitHub URL
uvx skillsmd add https://github.com/vercel-labs/agent-skills

# Direct path to a skill in a repo
uvx skillsmd add https://github.com/vercel-labs/agent-skills/tree/main/skills/web-design-guidelines

# GitLab URL
uvx skillsmd add https://gitlab.com/org/repo

# Any git URL
uvx skillsmd add git@github.com:vercel-labs/agent-skills.git

# Local path
uvx skillsmd add ./my-local-skills
```

--------------------------------

### SkillsOps Workflow Example

Source: https://pypi.org/project/skillsops

A typical workflow using skillsops: create a skill, edit its SKILL.md, validate and audit it, apply it to a local store, and then install it across IDEs. For existing skills, validation and installation can target specific file paths.

```bash
# Author from scratch.
skillctl create skill my-org/code-reviewer
# (edit SKILL.md)

# Validate and audit.
skillctl validate
skillctl eval audit .

# Push to your local content-addressed store.
skillctl apply

# Deploy to every IDE in the workspace.
skillctl install my-org/code-reviewer@0.1.0 --target all

# Or, working from an existing SKILL.md:
skillctl validate   ~/.claude/skills/code-reviewer/SKILL.md
skillctl eval audit ~/.claude/skills/code-reviewer/
skillctl install    ~/.claude/skills/code-reviewer/ --target cursor,windsurf,kiro
```

--------------------------------

### Install skill-mac-application-launcher from Source

Source: https://pypi.org/project/skill-mac-application-launcher

Clone the repository and install the skill from source using pip.

```bash
git clone https://github.com/OscillateLabsLLC/skill-mac-application-launcher
cd skill-mac-application-launcher
pip install .
```

--------------------------------

### Get Available Skills Output

Source: https://pypi.org/project/skill-to-mcp

Example output from the `get_available_skills` tool, listing all discovered skills with their names, descriptions, and file paths.

```json
[
  {
    "name": "single-cell-rna-qc",
    "description": "Performs quality control on single-cell RNA-seq data...",
    "path": "/path/to/skills/single-cell-rna-qc"
  }
]

```

--------------------------------

### Running Executable Files

Source: https://pypi.org/project/skill-security-scan

Examples of how to run the packaged executable file for help, scanning a directory, and generating a report.

```bash
# 直接运行，无需安装 Python
./dist/skill-security-scan.exe --help

# 扫描目录
./dist/skill-security-scan.exe scan /path/to/skill

# 生成报告
./dist/skill-security-scan.exe scan --output report.html

```

--------------------------------

### Development Environment Setup and Testing

Source: https://pypi.org/project/skill-lab

Install development dependencies with 'pip install -e .[dev]'. Run tests using 'pytest tests/ -v', type checking with 'mypy src/', and linting/formatting with 'ruff check src/' and 'ruff format src/'.

```bash
pip install -e ".[dev]"
```

```bash
pytest tests/ -v
```

```bash
mypy src/
```

```bash
ruff check src/
```

```bash
ruff format src/
```

--------------------------------

### Manual Shell Completion Setup

Source: https://pypi.org/project/skill

Provides the manual command to add shell completion for the 'skill' CLI if automatic installation is not preferred or fails.

```bash
# Add to your shell config:
eval "$(register-python-argcomplete skill)"
```

--------------------------------

### Example Configuration for skill-musicassistant

Source: https://pypi.org/project/skill-musicassistant

This JSON object shows an example configuration for the skill-musicassistant. Ensure 'music_assistant_url' and 'music_assistant_token' are correctly set.

```json
{
  "music_assistant_url": "http://localhost:8095",
  "music_assistant_token": "MUSIC_ASSISTANT_TOKEN",
  "default_player": "Living Room Speaker"
}
```

--------------------------------

### Install skill-hub-sdk

Source: https://pypi.org/project/skill-hub-sdk

Use this command to install the skill-hub-sdk package.

```bash
pip install skill-hub-sdk
```

--------------------------------

### Configure optional live evaluation setup

Source: https://pypi.org/project/skill-guard

Example configuration for skill-guard.yaml to set up live evaluations, including endpoint, model, and injection methods.

```yaml
test:
  endpoint: http://localhost:8000
  model: gpt-4.1
  workspace_dir: ./eval-workspace
  injection:
    method: custom_hook
    pre_test_hook: hooks/pre-test.sh
    post_test_hook: hooks/post-test.sh
  reload_health_check_path: /health
```

--------------------------------

### Usage Example with Gemini

Source: https://pypi.org/project/skillware

Demonstrates loading a skill, setting up a Gemini model with the skill's tools and instructions, and starting a chat session.

```python
import google.generativeai as genai
from skillware.core.loader import SkillLoader
from skillware.core.env import load_env_file

# Load Environment
load_env_file()

# 1. Load the Skill from the Registry
# The loader reads the code, manifest, and instructions automatically
skill_bundle = SkillLoader.load_skill("category/skill_name")

# 2. Model & Chat Setup
model = genai.GenerativeModel(
    'gemini-2.5-flash',
    tools=[SkillLoader.to_gemini_tool(skill_bundle)], # The "Adapter"
    system_instruction=skill_bundle['instructions']   # The "Mind"
)
chat = model.start_chat(enable_automatic_function_calling=True)

# 3. Agent Loop

```

--------------------------------

### Quick Start: SkillTailorClient

Source: https://pypi.org/project/skilltailor

Initialize SkillTailorClient and make a recommendation with a user profile. For local development, use 'http://127.0.0.1:8000' as the base URL. For production, use a reverse-proxied URL and ensure the backend listener is on '127.0.0.1:8000'.

```python
from skilltailor import SkillTailorClient

client = SkillTailorClient(base_url="https://your-domain.com/api")

result = client.recommend_with_profile(
    query="Recommend skills for support workflow automation",
    profile={
        "profile_id": "alice",
        "occupation": "Support engineer",
        "interests": ["automation", "ai agents"],
        "experience_level": "intermediate",
    },
)

print(result.results[0].skill_name)

```

--------------------------------

### Install All Skills

Source: https://pypi.org/project/skillpilot

Install all available skills at once using 'skillpilot install-all'.

```bash
# 5. Install all skills at once
skillpilot install-all

```

--------------------------------

### Command-line Usage for agentskill

Source: https://pypi.org/project/skillpm

These commands demonstrate how to install, list, update, remove, and get information about agent skills using the agentskill CLI.

```bash
agentskill install owner/repo           # install from GitHub
agentskill install ./local/skill        # install from local path
agentskill list                         # list installed skills
agentskill update skill-name            # update a skill
agentskill remove skill-name            # remove a skill
agentskill info skill-name              # show skill details
```

--------------------------------

### Install SkillKit with All Extras

Source: https://pypi.org/project/skillkit

Installs SkillKit with all extras, including LangChain integration and development tools. Recommended for full feature access.

```bash
pip install skillkit[all]
```

--------------------------------

### Manage Installed Skills with skillctl

Source: https://pypi.org/project/skillctl

List installed skills with 'skillctl list', use '--quiet' for bare names. Get detailed information with 'skillctl info'. Update skills individually or all at once with 'skillctl update'. Remove skills using 'skillctl remove'.

```bash
skillctl list                                 # Show installed skills
skillctl list --quiet                         # Bare names (for piping)
skillctl info my-skill                        # Detailed skill card
skillctl update my-skill                      # Pull latest from git
skillctl update --all                         # Update everything
skillctl remove my-skill                      # Uninstall (ref-counted clones)
```

--------------------------------

### Install a plugin bundle with skillpp

Source: https://pypi.org/project/skillpp

Install a plugin bundle using the 'install-plugin' command. Specify the publisher, name, and the repository containing the plugin bundle.

```bash
skillpp install-plugin --publisher acme --name suite --repo acme/suite

```

--------------------------------

### Quick Start: Run an Evaluation

Source: https://pypi.org/project/skillbench

Pull a skill and run a test evaluation against a specified adapter and model.

```bash
skillbench pull vercel-labs/skills/skills/find-skills
skillbench test ~/.skillbench/skills/vercel-labs/skills/find-skills \
  --adapter azure --model YOUR_DEPLOYMENT
```

--------------------------------

### Install with Development Dependencies

Source: https://pypi.org/project/skill-mac-application-launcher

Install the skill with development dependencies for local development.

```bash
pip install -e .[dev]
```

--------------------------------

### Run skill-openapi-bridge in an agent session

Source: https://pypi.org/project/skill-openapi-bridge

Demonstrates how to install the package, start the local server in the background, and make a request to the exposed API within an agent session.

```bash
pip install skill-openapi-bridge
skill-openapi-bridge serve brainstorming-topic-dialog-creative-mentor-en-openapi-spec.json &
sleep 1
curl http://localhost:52357/

```

--------------------------------

### Runtime Skill Loading Example

Source: https://pypi.org/project/skillforge

Shows how skills are loaded and applied within a specific project's runtime environment, demonstrating how user conventions are applied to the project's stack.

```bash
Project A: Next.js 15 + Supabase
  ├─ Loads: nextjs-fullstack + supabase-integration
  └─ Applies: YOUR conventions to THIS project stack
```

```bash
Project B: Vue.js + Firebase
  ├─ Loads: vue-spa + firebase-integration
  └─ Applies: YOUR conventions to THIS project stack
```

--------------------------------

### Install skillboard using pipx

Source: https://pypi.org/project/skillboard

Recommended installation method for skillboard using pipx.

```bash
pipx install skillboard

```

--------------------------------

### SkillScope Smart Recommendations with Filters

Source: https://pypi.org/project/skillscope

Examples of using the 'recommend' command with specific filters for region, budget, and skill level to get personalized skill suggestions.

```bash
# CN users: avoids skills depending on blocked services (Google, Slack, etc.)
skillscope recommend "send team notifications" --region cn

```

```bash
# Free budget: filters out skills requiring paid APIs
skillscope recommend "generate images" --budget free

```

```bash
# Beginner: prefers well-documented skills
skillscope recommend "deploy to AWS" --skill_level beginner

```

--------------------------------

### Complete Schema Example for skillsible Manifest

Source: https://pypi.org/project/skillsible

This example demonstrates the full structure of a skillsible manifest file, including definitions for agents, defaults, skills, tools, and MCPs. It shows how to specify sources, versions, agents, and scopes for skills, as well as details for installing and verifying tools and configuring MCPs.

```yaml
version: 1  # Manifest format version

agents:
  - codex       # Default target agent
  - claude-code # Also receives any skill that does not override `agents`

defaults:
  scope: global # Default scope: install for the current user across projects

skills:
  - source: obra/the-elements-of-style
    skill: writing-clearly-and-concisely # Required: skill directory name
    version: v1.2.0 # Optional: branch, tag, or commit SHA
    # No `agents` field here, so this inherits both top-level agents:
    #   - codex
    #   - claude-code
    # No `scope` field here, so this inherits `defaults.scope = global`

  - source: obra/the-elements-of-style
    skill: writing-clearly-and-concisely
    version: main # A skill version can be a branch, tag, or commit SHA
    agents:
      - codex # Optional override: target only codex
    scope: project # Optional override: install only for the current project

tools:
  - name: pyright
    kind: lsp # Required: free-form category like lsp or cli
    source:
      npm:
        package: pyright
        version: 1.1.399
    verify:
      command: pyright
      args:
        - --version

  - name: ruff
    kind: cli
    source:
      uv:
        package: ruff
        version: 0.13.0
    verify:
      command: ruff
      args:
        - --version

mcps:
  - name: github
    transport: stdio # Optional: transport hint such as stdio, http, or sse
    command: github-mcp # Required for stdio MCPs
    args:
      - --serve
    env:
      GITHUB_TOKEN: ${GITHUB_TOKEN}
    agents:
      - claude-code

  - name: linear
    transport: http
    url: http://localhost:8765/mcp # Required for HTTP/SSE MCPs
    bearer_token_env_var: LINEAR_TOKEN # Optional: Codex bearer token env hook

```