Provides tools for managing per-skill environment variables stored in .env files, including setting and reading configuration values for skill execution
Enables programmatic management of skill files and directories, including creating, reading, updating, and deleting files within the skills directory structure
Supports version control integration for skills management, allowing skills to be tracked and versioned using git repositories
Supports GitHub integration through environment variable management for GitHub API tokens and related GitHub workflow automation
Provides tools for managing SKILL.md files and other Markdown documentation within the skills directory structure
Integrates with PyPI for automatic package distribution and installation via uvx, allowing the MCP server to be run directly from PyPI packages
Allows execution of Python scripts with automatic dependency management using PEP 723 inline metadata, enabling scripts to declare and automatically install their own dependencies
Enables execution of shell/bash scripts and other executable scripts with environment variable injection and output capture
Enables parsing and management of YAML frontmatter in skill files for metadata extraction and skill descriptions
Skill Management MCP Server
A Model Context Protocol (MCP) server that enables Claude to manage skills stored in ~/.skill-mcp/skills
. This system allows Claude to create, edit, run, and manage skills programmatically, including execution of skill scripts with environment variables.
Quick Status
Status: ā
Production Ready
Test Coverage: 82% (78/78 tests passing)
Deployed: October 18, 2025
Architecture: 19-module modular Python package
Overview
This project consists of two main components:
MCP Server (
src/skill_mcp/server.py
) - A refactored Python package providing 9 tools for skill managementSkills Directory (
~/.skill-mcp/skills/
) - Where you store and manage your skills
Key Advantages
š Not Locked to Claude UI
Unlike the Claude interface, this system uses the Model Context Protocol (MCP), which is:
ā Universal - Works with Claude Desktop, claude.ai, Cursor, and any MCP-compatible client
ā Not tied to Claude - Same skills work everywhere MCP is supported
ā Future-proof - Not dependent on Claude's ecosystem or policy changes
ā Local-first - Full control over your skills and data
šÆ Use Skills Everywhere
Your skills can run in:
Cursor - IDE integration with MCP support
Claude Desktop - Native app with MCP access
claude.ai - Web interface with MCP support
Any MCP client - Growing ecosystem of compatible applications
š¦ Independent & Modular
ā Each skill is self-contained with its own files, scripts, and environment
ā No dependency on proprietary Claude features
ā Can be versioned, shared, and reused across projects
ā Standard MCP protocol ensures compatibility
š Share Skills Across All MCP Clients
ā One skill directory, multiple clients - Create once, use everywhere
ā Same skills in Cursor and Claude - No duplication needed
ā Seamless switching - Move between tools without reconfiguring
ā Consistent experience - Skills work identically across all MCP clients
ā Centralized management - Update skills in one place, available everywhere
š¤ LLM-Managed Skills (No Manual Copy-Paste)
Instead of manually copying, zipping, and uploading files:
Key Benefits:
ā No manual file operations - LLM handles creation, editing, deletion
ā Instant changes - No upload/download/reload cycles
ā Full version control - Skills are regular files, can use git
ā Easy modification - LLM can edit scripts on the fly
ā Testable - LLM can create and run scripts immediately
ā Collaborative - Teams can develop skills together via MCP
Features
Skill Management
ā List all available skills
ā Browse skill files and directory structure
ā Read skill files (SKILL.md, scripts, references, assets)
ā Create new skill files and directories
ā Update existing skill files
ā Delete skill files
Script Execution
ā Run Python, Bash, and other executable scripts
ā Automatic dependency management for Python scripts using uv inline metadata (PEP 723)
ā Automatic environment variable injection from secrets
ā Command-line argument support
ā Custom working directory support
ā Capture stdout and stderr
ā 30-second timeout for safety
Environment Variables
ā List environment variable keys (secure - no values shown)
ā Set or update environment variables per skill
ā Persistent storage in per-skill
.env
filesā Automatic injection into script execution
Directory Structure
Quick Start
1. Install uv
This project uses uv for fast, reliable Python package management.
2. Configure Your MCP Client
Add the MCP server to your configuration. The server will be automatically downloaded and run via uvx
from PyPI.
Claude Desktop - Edit the config file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.json
Windows:
%APPDATA%\Claude\claude_desktop_config.json
Linux:
~/.config/Claude/claude_desktop_config.json
Cursor - Edit the config file:
macOS:
~/.cursor/mcp.json
Windows:
%USERPROFILE%\.cursor\mcp.json
Linux:
~/.cursor/mcp.json
That's it! No installation needed - uvx
will automatically download and run the latest version from PyPI.
3. Restart Your MCP Client
Restart Claude Desktop or Cursor to load the MCP server.
4. Test It
In a new conversation:
Claude should use the skill-mcp tools to show skills in ~/.skill-mcp/skills/
.
Common uv Commands
For development in this repository:
Note: uv automatically creates and manages .venv/
- no need to manually create virtual environments!
Script Dependencies (PEP 723)
Python scripts can declare their own dependencies using uv's inline metadata. The server automatically detects this and uses uv run
to handle dependencies:
Benefits:
ā No manual dependency installation needed
ā Each script has isolated dependencies
ā Works automatically when run via
run_skill_script
ā Version pinning ensures reproducibility
How it works:
You add inline metadata to your Python script
When the script runs via
run_skill_script
, the server detects the metadatauv automatically creates an isolated environment and installs dependencies
The script runs with access to those dependencies
No manual
pip install
or virtual environment management needed!
Example: See example-skill/scripts/fetch_data.py
for a working example.
Testing locally:
Usage Examples
Creating a New Skill
Managing Environment Variables
Running Skill Scripts
Modifying Existing Skills
Available MCP Tools
The server provides these tools to Claude:
Tool | Purpose |
| List all skills in ~/.skill-mcp/skills |
| Get comprehensive details about a specific skill |
| Read content of a skill file |
| Create a new file in a skill |
| Update an existing skill file |
| Delete a skill file |
| Execute a script with environment variables |
| List environment variable keys for a skill (values hidden) |
| Create/update a skill's .env file |
Security Features
Path Validation
All file paths are validated to prevent directory traversal attacks
Paths with ".." or starting with "/" are rejected
All operations are confined to the skill directory
Environment Variables
Variable values are never exposed when listing
Stored in per-skill
.env
filesFile permissions should be restricted (chmod 600 on each .env)
Script Execution
30-second timeout prevents infinite loops
Scripts run with user's permissions (not elevated)
Output size limits prevent memory issues
Capture both stdout and stderr for debugging
Troubleshooting
"MCP server not found"
Check that
uv
is in your PATH:which uv
(orwhere uv
on Windows)Verify the path to
.skill-mcp
directory is correct and absoluteTest dependencies:
cd ~/.skill-mcp && uv run python -c "import mcp; print('OK')"
Ensure
pyproject.toml
exists in~/.skill-mcp/
"Permission denied" errors
Scripts failing to execute
Check script has execute permissions
Verify interpreter (python3, bash) is in PATH
Use
list_env_keys
to check required variables are setCheck stderr output from
run_skill_script
Environment variables not working
Verify they're set: use
read_skill_env
for the skillCheck the .env file exists:
cat ~/.skill-mcp/skills/<skill-name>/.env
Ensure your script is reading from
os.environ
Advanced: Tool Descriptions for LLMs
All MCP tools have been enhanced with detailed descriptions to prevent confusion:
Skill Tools
list_skills - Lists all skills with descriptions, paths, and validation status
get_skill_details - Complete skill information: SKILL.md content, all files, scripts, environment variables
File Tools
read_skill_file - Read any file in a skill directory
create_skill_file - Create new files (auto-creates parent directories)
update_skill_file - Update existing files (replaces entire content)
delete_skill_file - Delete files permanently (path-traversal protected)
Script Tools
run_skill_script - Execute scripts with automatic PEP 723 dependency detection
read_skill_env - List environment variables for a skill (keys only, values hidden for security)
update_skill_env - Create/update a skill's .env file
Advanced Configuration
Custom Directories
Edit skill_mcp_server.py
to change default locations:
(No global secrets file; env vars are per-skill .env)
Resource Limits
Adjust limits in skill_mcp_server.py
:
Script timeout in the run_skill_script
function:
Architecture & Implementation
Package Structure
What's New
Enhanced Features:
ā Skill descriptions extracted from YAML frontmatter
ā Comprehensive skill details (files, scripts, metadata)
ā File type detection (Python, Markdown, etc.)
ā Executable identification with metadata
ā PEP 723 uv dependency detection - scripts declare own dependencies
ā Per-skill environment variables (.env files)
ā Automatic dependency management for scripts
Breaking Changes:
Removed global
~/.skill-mcp/secrets
(now per-skill .env files)Removed
list_env_keys
andset_env
global toolsReplaced
get_skill_files
with more comprehensiveget_skill_details
Test Results
Unit Tests: 78/78 Passing ā
Coverage: 82% (522/641 statements covered)
Comprehensive test coverage across all modules:
Module | Coverage | Tests |
Core Config | 100% | All paths |
Models | 100% | Input/Output validation |
Exception Handling | 100% | All exception types |
YAML Parser | 90% | Frontmatter parsing |
Skill Service | 90% | Skill discovery & metadata |
File Service | 89% | File operations |
Environment Service | 83% | .env management |
Skill Tools | 85% | Skill management tools |
File Tools | 79% | File operation tools |
Script Detector | 87% | Script capability detection |
Path Utils | 86% | Path validation & security |
Server | 67% | MCP tool registration |
Script Service | 53% | Script execution |
Script Tools | 61% | Script execution tools |
Test Breakdown:
ā Path utilities: 4 tests
ā YAML parsing: 7 tests
ā Environment service: 7 tests
ā File service: 4 tests
ā Skill service: 5 tests
ā Script detector: 20 tests
ā Script service: 7 tests
ā Integration tests: 24 tests
Manual Tests: All Passed ā
ā List skills with YAML descriptions
ā Get comprehensive skill details with SKILL.md content
ā Read/create/update/delete files
ā Read/update environment variables
ā Execute scripts with auto-dependencies
ā Weather-fetcher example runs successfully
Verification Checklist
ā Server imports successfully
ā All 9 tools registered and callable
ā 78/78 unit tests passing (82% coverage)
ā All manual tests passing
ā .cursor/mcp.json configured
ā Package deployed and active
ā Scripts execute successfully
ā File operations working
ā Environment variables working
ā Backward compatible with existing skills
Best Practices
Skill Development
Follow the standard skill structure (SKILL.md, scripts/, references/, assets/)
Keep SKILL.md concise and focused
Use progressive disclosure (split large docs into references)
Test scripts immediately after creation
Environment Variables
Use descriptive names (API_KEY, DATABASE_URL)
Never log or print sensitive values
Set permissions on .env files:
chmod 600 ~/.skill-mcp/skills/<skill-name>/.env
Script Development
Use meaningful exit codes (0 = success)
Print helpful messages to stdout
Print errors to stderr
Include error handling
For Python scripts with dependencies: Use inline metadata (PEP 723)
# /// script # dependencies = [ # "package-name>=version", # ] # ///Scripts without metadata use the system Python interpreter
Scripts with metadata automatically get isolated environments via uv
š Managing Sensitive Secrets Safely
To prevent LLMs from accessing your sensitive credentials:
ā RECOMMENDED: Update .env files directly on the file system
Why this is important:
ā LLMs never see your sensitive values
ā Secrets stay on your system only
ā No risk of credentials appearing in logs or outputs
ā Full control over sensitive data
ā Can be used with
git-secret
or similar tools for versioning
Workflow:
Claude creates the skill structure and scripts
You manually add sensitive values to
.env
filesClaude can read the
.env
keys (without seeing values) and use themScripts access secrets via environment variables at runtime
Example:
ā NEVER DO:
ā Tell Claude your actual API keys or passwords
ā Ask Claude to set environment variables with sensitive values
ā Store secrets in SKILL.md or other tracked files
ā Use
update_skill_env
tool with real secrets (only for non-sensitive config)
ā DO:
ā Update
.env
files manually on your systemā Keep
.env
files in.gitignore
ā Use
chmod 600
to restrict file accessā Tell Claude only the variable names (e.g., "the API key is in API_KEY")
ā Keep secrets completely separate from LLM interactions
ā ļø Important: Verify LLM-Generated Code
When Claude or other LLMs create or modify skills and scripts using this MCP system, always verify the generated code before running it in production:
Security Considerations
ā ļø Always review generated code - LLMs can make mistakes or generate suboptimal code
ā ļø Check for security issues - Look for hardcoded credentials, unsafe operations, or vulnerabilities
ā ļø Test thoroughly - Run scripts in isolated environments first
ā ļø Validate permissions - Ensure scripts have appropriate file and system permissions
ā ļø Monitor dependencies - Review any external packages installed via PEP 723
Best Practices for LLM-Generated Skills
Review before execution - Always read through generated scripts
Test in isolation - Run in a safe environment before production use
Use version control - Track all changes with git for audit trails
Implement error handling - Add robust error handling and logging
Set resource limits - Use timeouts and resource constraints
Run with minimal permissions - Don't run skills as root or with elevated privileges
Validate inputs - Sanitize any user-provided data
Audit logs - Review what scripts actually do and track their execution
Common Things to Check
ā Hardcoded API keys, passwords, or tokens
ā Unsafe file operations or path traversal risks
ā Unvalidated external commands or shell injection risks
ā Missing error handling or edge cases
ā Resource-intensive operations without limits
ā Unsafe deserialization (eval, pickle, etc.)
ā Excessive permissions requested
ā Untrustworthy external dependencies
When in Doubt
Ask Claude/LLM to explain the code
Have another person review critical code
Use linters and security scanning tools
Run in containers or VMs for isolation
Start with read-only operations before destructive ones
Remember: LLM-generated code is a starting point. Your verification and review are essential for security and reliability.
Installation from PyPI
To install the package globally (optional):
Or use uvx
to run without installation (recommended):
Development Setup
If you want to contribute or run from source:
To use your local development version in your MCP client config:
License
MIT License
Copyright (c) 2025
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Contributing
This is a custom tool for personal use. Feel free to fork and adapt for your needs.
Support
For setup issues or questions, refer to:
Claude's MCP documentation at https://modelcontextprotocol.io
The MCP Python SDK docs at https://github.com/modelcontextprotocol/python-sdk
local-only server
The server can only run on the client's local machine because it depends on local resources.
Tools
Enables Claude to create, edit, run, and manage reusable skills stored locally, including executing scripts with automatic dependency management and environment variables. Works across all MCP-compatible clients like Cursor, Claude Desktop, and claude.ai.
- Quick Status
- Overview
- Key Advantages
- Features
- Directory Structure
- Quick Start
- Common uv Commands
- Script Dependencies (PEP 723)
- Usage Examples
- Available MCP Tools
- Security Features
- Troubleshooting
- Advanced: Tool Descriptions for LLMs
- Advanced Configuration
- Architecture & Implementation
- Test Results
- Verification Checklist
- Best Practices
- ā ļø Important: Verify LLM-Generated Code
- Installation from PyPI
- Development Setup
- License
- Contributing
- Support