This MCP server converts Claude Skills into accessible resources, enabling LLM applications to discover and utilize predefined skills through three core tools:
Discover available skills (get_available_skills) - Automatically find and list all skills in your configured directory with their names, descriptions, and paths
Get skill details (get_skill_details) - Retrieve the full SKILL.md content (markdown with YAML frontmatter) and a complete list of all files within a specific skill, with flexible return options (content, file path, or both)
Access skill files (get_skill_related_file) - Read any file within a skill directory (scripts, data, references, etc.) using relative paths
Key Features:
Automatic skill discovery through recursive SKILL.md file detection
Built-in security with path validation to prevent directory traversal attacks
Support for multiple skill collections across different directories for organizing by domain or project
Flexible deployment options: locally, via HTTP transport, or Docker containers
Domain-agnostic design that works with any Claude Skills format collection, optimized for biomedical research through BioContextAI
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Skill-to-MCP list all available skills"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Convert AI Skills (following Claude Skills format) into MCP server resources, making them accessible through the Model Context Protocol.
Part of BioContextAI - A community-driven initiative connecting agentic AI with biomedical resources through standardized MCP servers. While this package is domain-agnostic and can be used for any skill collection, it was developed to support the biomedical research community.
This MCP server exposes Claude Skills as resources that can be accessed by LLM applications through the Model Context Protocol. Skills are self-contained directories containing a SKILL.md file with YAML frontmatter, along with supporting files like scripts, references, and examples.
Automatic skill discovery: Recursively finds all SKILL.md files in the skills/ directory
Frontmatter parsing: Extracts skill metadata (name, description) from YAML frontmatter
Three core tools:
get_available_skills: Lists all available skills with descriptions
get_skill_details: Returns SKILL.md content and file listing for a specific skill
get_skill_related_file: Reads any file within a skill directory (with directory traversal protection)
Security: Path validation prevents access outside skill directories
Related MCP server: Skillz
Please refer to the documentation for comprehensive guides, or jump to:
Configuration - Set up your skills directory
Usage - Learn about the three core tools
Creating Skills - Build your own skills
Installation - Multiple installation options
Documentation: skill-to-mcp.readthedocs.io
BioContextAI Registry: biocontext.ai/registry
API Reference: API documentation
Source Code: GitHub
Issue Tracker: GitHub Issues
The MCP server requires a skills directory to be specified. This allows you to:
Install the package separately from your skills
Edit skills without modifying the package
Use different skill collections for different projects
Set the skills directory using either:
Command-line option: --skills-dir /path/to/skills
Environment variable: SKILLS_DIR=/path/to/skills
{
"mcpServers": {
"skill-to-mcp": {
"command": "uvx",
"args": ["skill_to_mcp", "--skills-dir", "/path/to/your/skills"],
"env": {
"UV_PYTHON": "3.12"
}
}
}
}Or using environment variables:
{
"mcpServers": {
"skill-to-mcp": {
"command": "uvx",
"args": ["skill_to_mcp"],
"env": {
"UV_PYTHON": "3.12",
"SKILLS_DIR": "/path/to/your/skills"
}
}
}
}Once configured in your MCP client, the server provides three tools:
Returns a list of all available skills with metadata:
[
{
"name": "single-cell-rna-qc",
"description": "Performs quality control on single-cell RNA-seq data...",
"path": "/path/to/skills/single-cell-rna-qc"
}
]Returns the full SKILL.md content and list of files for a specific skill:
{
"skill_content": "---\nname: single-cell-rna-qc\n...",
"files": ["SKILL.md", "scripts/qc_analysis.py", "references/guidelines.md"]
}The return_type parameter controls what data is returned:
"content": Returns only the SKILL.md content as text
"file_path": Returns only the absolute path to SKILL.md
"both" (default): Returns both content and file path in a dict
Reads a specific file within a skill directory:
get_skill_related_file(
skill_name="single-cell-rna-qc",
relative_path="scripts/qc_analysis.py",
return_type="content" # "content", "file_path", or "both" (default)
)Add to your claude_desktop_config.json:
{
"mcpServers": {
"biomedical-skills": {
"command": "uvx",
"args": [
"skill_to_mcp",
"--skills-dir",
"/Users/yourname/biomedical-skills"
],
"env": {
"UV_PYTHON": "3.12"
}
}
}
}You can run multiple instances with different skill directories:
{
"mcpServers": {
"biomedical-skills": {
"command": "uvx",
"args": ["skill_to_mcp", "--skills-dir", "/path/to/biomedical-skills"]
},
"data-science-skills": {
"command": "uvx",
"args": ["skill_to_mcp", "--skills-dir", "/path/to/data-science-skills"]
}
}
}Skills should be placed in your configured skills directory. Each skill must:
Have its own subdirectory
Contain a SKILL.md file with YAML frontmatter
Follow the frontmatter format:
---
name: my-skill-name
description: Brief description of what this skill does and when to use it
---
# Skill Content
Instructions and documentation go here...Use lowercase letters, numbers, and hyphens only
Maximum 64 characters
No XML tags or reserved words
See the included example skills/single-cell-rna-qc/SKILL.md for a complete reference.
my-skills/
├── skill-1/
│ ├── SKILL.md
│ ├── scripts/
│ └── references/
├── skill-2/
│ ├── SKILL.md
│ └── data/
└── skill-3/
└── SKILL.mdYou need to have Python 3.11 or newer installed on your system. If you don't have Python installed, we recommend installing uv.
There are several alternative options to install skill-to-mcp:
Use uvx to run it immediately (requires SKILLS_DIR environment variable):
SKILLS_DIR=/path/to/skills uvx skill_to_mcpOr with the command-line option:
uvx skill_to_mcp --skills-dir /path/to/skillsInclude it in various MCP clients that support the mcp.json standard:
{
"mcpServers": {
"skill-to-mcp": {
"command": "uvx",
"args": ["skill_to_mcp", "--skills-dir", "/path/to/your/skills"],
"env": {
"UV_PYTHON": "3.12"
}
}
}
}Install it through pip:
pip install --user skill_to_mcpInstall the latest development version:
pip install git+https://github.com/biocontext-ai/skill-to-mcp.git@mainFor development and testing:
# Using uvx (recommended)
SKILLS_DIR=/path/to/skills uvx skill_to_mcp
# Using pip
pip install skill_to_mcp
skill_to_mcp --skills-dir /path/to/skillsFor production environments with HTTP transport:
export MCP_ENVIRONMENT=PRODUCTION
export SKILLS_DIR=/path/to/skills
export MCP_TRANSPORT=http
export MCP_PORT=8000
skill_to_mcpCreate a Dockerfile:
FROM python:3.12-slim
WORKDIR /app
RUN pip install skill_to_mcp
COPY skills /app/skills
ENV SKILLS_DIR=/app/skills
ENV MCP_TRANSPORT=http
ENV MCP_PORT=8000
CMD ["skill_to_mcp"]Build and run:
docker build -t skill-to-mcp .
docker run -p 8000:8000 skill-to-mcpBioContextAI is a community effort to connect agentic artificial intelligence with biomedical resources using the Model Context Protocol. The Registry is a community-driven catalog of MCP servers for biomedical research, enabling researchers and developers to discover, access, and contribute specialized tools and databases.
Key Principles:
FAIR4RS Compliant: Findable, Accessible, Interoperable, Reusable for Research Software
Community-Driven: Open-source and collaborative development
Standardized: Built on the Model Context Protocol specification
Contributions are welcome! See CONTRIBUTING.md for guidelines on:
Development setup
Code style requirements
Testing procedures
Pull request process
To contribute skills to the biomedical community, consider adding them to the BioContextAI Registry.
If you found a bug, please use the issue tracker.
For questions about BioContextAI or the registry, visit biocontext.ai.
If you use this software in your research, please cite the BioContextAI paper:
@article{BioContext_AI_Kuehl_Schaub_2025,
title={BioContextAI is a community hub for agentic biomedical systems},
url={http://dx.doi.org/10.1038/s41587-025-02900-9},
urldate = {2025-11-06},
doi={10.1038/s41587-025-02900-9},
year = {2025},
month = nov,
journal={Nature Biotechnology},
publisher={Springer Science and Business Media LLC},
author={Kuehl, Malte and Schaub, Darius P. and Carli, Francesco and Heumos, Lukas and Hellmig, Malte and Fernández-Zapata, Camila and Kaiser, Nico and Schaul, Jonathan and Kulaga, Anton and Usanov, Nikolay and Koutrouli, Mikaela and Ergen, Can and Palla, Giovanni and Krebs, Christian F. and Panzer, Ulf and Bonn, Stefan and Lobentanzer, Sebastian and Saez-Rodriguez, Julio and Puelles, Victor G.},
year={2025},
month=nov,
language={en},
}Example Skill: The included single-cell-rna-qc skill is adapted from Anthropic's Life Sciences repository
Anthropic: For developing Claude Skills and the Model Context Protocol
scverse®: The scverse community (scverse.org) for best practices in single-cell analysis
BioContextAI Community: For fostering open-source biomedical AI infrastructure
This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
Note: While this software is open-source, individual skills may have their own licenses. Users are responsible for compliance with the licenses of any skills they use or distribute.
Get an overview of all available skills.
This tool provides LLMs with a list of available skills and their use cases by parsing the frontmatter (YAML metadata) at the start of each SKILL.md file.
LLMs should rely on this tool to discover what skills are available before requesting detailed skill information.
list[dict[str, str]] List of skill metadata dictionaries, each containing: - name: The skill identifier (lowercase, hyphens only) - description: When and how to use this skill - path: Location of the skill directory
skills = get_available_skills() print(skills[0]["name"]) 'single-cell-rna-qc'
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that the tool parses frontmatter and returns a list of skill metadata with specific fields (name, description, path) and naming conventions (lowercase, hyphens only). This is sufficient for a read-only tool with no side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections, a clear returns specification, and an example. Every sentence contributes useful information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no annotations, output schema exists), the description fully covers the tool's purpose, usage guidance, output format, and relationship to siblings. It is complete for an agent to correctly select and invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, and schema coverage is 100%, so no parameter information is needed. The description adds value by explaining what the output contains, but per guidelines, 0 parameters yields a baseline of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides an overview of all available skills by parsing SKILL.md frontmatter. It distinguishes from siblings (get_skill_details, get_skill_related_file) by focusing on discovery of skills rather than details or files.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises LLMs to use this tool before requesting detailed skill information, providing clear usage context. It doesn't explicitly mention when not to use, but the guidance is strong and alternatives are implied through sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific skill.
This tool provides the full SKILL.md content and/or file path, along with a recursive list of all files contained within the skill's directory. LLMs should use get_skill_related_file() to read the content of specific files.
skill_name : str The name of the skill (from get_available_skills). return_type : str Type of data to return: "content" (default), "file_path", or "both". - "content": Returns only the SKILL.md content as text - "file_path": Returns only the absolute path to SKILL.md - "both": Returns both content and file path in a dict
dict[str, any] Dictionary containing: - skill_content: Full text or path of SKILL.md (based on return_type) - files: List of relative file paths in the skill directory
ValueError If the skill is not found or return_type is invalid.
details = get_skill_details("single-cell-rna-qc", return_type="content") print(details["files"]) ['SKILL.md', 'scripts/qc_analysis.py', ...]
| Name | Required | Description | Default |
|---|---|---|---|
| skill_name | Yes | ||
| return_type | No | both |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description carries full burden. It discloses return types (content/file_path/both), file list, and error conditions. It does not explicitly state read-only nature but implies it through output description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with sections (Parameters, Returns, Raises, Examples). Slightly lengthy but all content is relevant and earned. Front-loaded purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, description fully documents return dict structure and exception. Relationship to siblings is clear. No gaps identified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage; description fully explains both parameters: skill_name (source from get_available_skills) and return_type (with options and defaults). Adds significant value beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves detailed info about a specific skill. It distinguishes from siblings: get_available_skills lists skills, get_skill_related_file reads file contents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description advises to use get_skill_related_file to read specific files, providing practical guidance on tool selection. However, it does not explicitly state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.2.0get_available_skills1 field changedOutput schema / descriptionAdded value: +"Generic wrapper for non-object return types."get_skill_related_file1 field changedOutput schema / descriptionAdded value: +"Generic wrapper for non-object return types."get_available_skillsget_skill_detailsget_skill_related_fileScored across 3 tools
Each tool has a distinct, non-overlapping purpose: listing available skills, getting detailed information about a specific skill, and reading a file within a skill's directory. No ambiguity.
All tools follow a consistent verb_noun snake_case pattern with 'get_' prefix, making the naming predictable and clear.
Three tools is on the low side but appropriate for a read-only skill retrieval server. Each tool is essential and earns its place.
The tool set fully covers the domain of skill retrieval: discovery, details, and file access. No obvious gaps for the stated purpose.
Hosted MCP server for live public-data APIs and Skills for AI agents.
Governed AI agent skills — one library, distributed to devs and exposed to remote agents over MCP.
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Manage portable AI agent playbooks, Agent Skills, MCP configurations, personas, and memory.
