Skill Management MCP Server

Unified CRUD tool for skill management.

IMPORTANT NOTES:

• Skills are stored in ~/.skill-mcp/skills directory

• All file paths in responses are relative to the skill directory (e.g., 'main.py', not full paths)

• To execute scripts, use the 'run_skill_script' tool, NOT external bash/shell tools

Operations:

• create: Create a new skill with templates (basic, python, bash, nodejs)

• list: List all skills with optional search (supports text and regex)

• search: Search for skills by pattern (text or regex)

• get: Get detailed information about a specific skill

• validate: Validate skill structure and get diagnostics

• delete: Delete a skill directory (requires confirm=true)

• list_templates: List all available skill templates with descriptions

Examples:

Unified CRUD tool for skill file operations. Supports both single and bulk operations.

IMPORTANT PATH NOTES:

• All file paths are RELATIVE to the skill directory (e.g., 'main.py', 'scripts/utils.py')

• NEVER use absolute paths (e.g., NOT '/Users/username/.skill-mcp/skills/my-skill/main.py')

• To execute scripts, use the 'run_skill_script' tool, NOT external bash/shell tools

Operations:

• read: Read a file's content

• create: Create one or more files (supports atomic mode for bulk)

• update: Update one or more files

• delete: Delete a file (SKILL.md is protected and cannot be deleted)

Single File Examples:

Bulk File Examples:

Unified CRUD tool for skill environment variable operations. Supports single and bulk operations.

Operations:

• read: Read all environment variable keys (values are hidden for security)

• set: Set one or more environment variables (merges with existing)

• delete: Delete one or more environment variables

• clear: Clear all environment variables

Examples:

Note: The 'set' operation always merges with existing variables. To replace everything, use 'clear' first, then 'set'.

Execute Python code directly without requiring a script file.

RECOMMENDATION: Prefer Python over bash/shell scripts for better portability, error handling, and maintainability.

IMPORTANT: Use this tool instead of creating temporary script files when you need to run quick Python code.

✅ SUPPORTS PEP 723 INLINE DEPENDENCIES - just like run_skill_script!

FEATURES:

• PEP 723 inline dependencies: Include dependencies directly in code using /// script comments (auto-detected and installed)

• Dependency aggregation: When importing from skills, their PEP 723 dependencies are automatically merged into your code

• Skill file imports: Reference files from skills using namespace format (skill_name:path/to/file.py)

• Automatic dependency installation: Code with PEP 723 metadata is run with 'uv run'

• Environment variable loading: Automatically loads .env files from all referenced skills

• Clean execution: Temporary file is automatically cleaned up after execution

PARAMETERS:

• code: Python code to execute (can include PEP 723 dependencies)

• skill_references: Optional list of skill files to make available for import Format: ["calculator:utils.py", "weather:api/client.py"] The skill directories will be added to PYTHONPATH Environment variables from each skill's .env file will be loaded

• timeout: Optional timeout in seconds (defaults to 30 seconds if not specified)

CROSS-SKILL IMPORTS - BUILD REUSABLE LIBRARIES: Create utility skills once, import them anywhere! Perfect for:

• Math/statistics libraries (calculator:stats.py)

• API clients (weather:api_client.py)

• Data processors (etl:transformers.py)

• Common utilities (helpers:string_utils.py)

AUTOMATIC DEPENDENCY AGGREGATION: When you reference skill files, their PEP 723 dependencies are automatically collected and merged into your code! You don't need to redeclare dependencies - just reference the modules and their deps are included automatically.

Example - library module with deps:

Your code - NO need to declare requests!

Dependencies from json_fetcher.py are automatically aggregated!

Import from single skill:

Import from multiple skills:

Import from subdirectories:

ENVIRONMENT VARIABLES FROM REFERENCED SKILLS: When you import from a skill, its environment variables are automatically loaded:

If weather:api_client.py uses API_KEY from its .env file, it will be available automatically!

EXAMPLE WITH PEP 723 DEPENDENCIES:

WHY PYTHON OVER BASH/JS:

• Better error handling and debugging

• Rich standard library

• Cross-platform compatibility

• Easier to read and maintain

• Strong typing support

• Better dependency management

RETURNS: Execution result with:

• Exit code (0 = success, non-zero = failure)

• STDOUT (standard output)

• STDERR (error output)

Execute a script within a skill directory. Skills are modular libraries with reusable code - scripts can import from their own modules or use external dependencies.

IMPORTANT: ALWAYS use this tool to execute scripts. DO NOT use external bash/shell tools to execute scripts directly. This tool provides:

• Automatic dependency management (Python PEP 723, npm packages)

• Proper environment variable injection from .env files

• Secure execution within skill directory boundaries

• Proper error handling and output capture

SKILLS AS LIBRARIES: Scripts within a skill can import from local modules naturally:

In main.py:

Execute with:

SUPPORTED LANGUAGES:

• Python: Automatically detects and installs PEP 723 inline dependencies via 'uv run'

• JavaScript/Node.js: Automatically runs 'npm install' if package.json exists

• Bash: Executes shell scripts (.sh files)

• Other: Any executable file with proper shebang line

FEATURES:

• Module imports: Scripts can import from other files within the skill directory

• Automatic PEP 723 dependency detection: Python scripts with inline metadata are automatically run with 'uv run'

• Automatic npm dependency installation: Node.js scripts install dependencies from package.json

• Environment variables: Loads skill-specific .env file and injects variables into script environment

• Working directory: Can specify a subdirectory to run the script from

• Arguments: Pass command-line arguments to the script

• Output capture: Returns stdout, stderr, and exit code

PEP 723 AUTOMATIC DEPENDENCY DETECTION: Python scripts with inline dependencies are automatically detected and executed with 'uv run':

Example Python script with PEP 723 (e.g., weather-skill/fetch_weather.py):

Execute with automatic dependency handling:

No manual dependency installation needed - the server automatically:

1. Detects the PEP 723 metadata in your script

2. Uses 'uv run' to create an isolated environment

3. Installs the declared dependencies

4. Executes your script with access to those dependencies

PARAMETERS:

• skill_name: The name of the skill directory (e.g., 'weather-skill')

• script_path: Relative path to the script within skill directory (e.g., 'main.py', 'scripts/fetch_weather.py', 'bin/process.sh')

• args: Optional list of command-line arguments (e.g., ['--verbose', 'input.txt'])

• working_dir: Optional working directory relative to skill root (e.g., 'scripts')

• timeout: Optional timeout in seconds (defaults to 30 seconds if not specified)

IMPORTANT PATH NOTES:

• All paths are RELATIVE to the skill directory, never absolute paths

• Script path example: 'main.py' NOT '/Users/username/.skill-mcp/skills/my-skill/main.py'

• Working dir example: 'scripts' NOT '/full/path/to/scripts'

RETURNS: Script execution result with:

• Exit code (0 = success, non-zero = failure)

• STDOUT (standard output)

• STDERR (error output)