Claude Skills MCP Server

claude-skills-mcp · K-Dense-AI/claude-skills-mcp · ★ 387 · last commit 2026-04-08

Primitive shape 3 total

MCP tools 3

Summary

Claude Skills MCP Server — Summary

Claude Skills MCP Server is a Python-based MCP server that brings Anthropic's Agent Skills framework to any MCP-compatible AI assistant via semantic vector search. It uses a two-package architecture (lightweight claude-skills-mcp frontend proxy + heavy claude-skills-mcp-backend with PyTorch/sentence-transformers) so that Cursor and other clients receive an instant response while the 250 MB RAG backend downloads in the background. The server ships three MCP tools: find_helpful_skills (semantic search), read_skill_document (progressive content loading), and list_skills (inventory). It indexes from Anthropic's official skills repository plus K-Dense AI's scientific skills (~90 skills at default config), with configurable additional GitHub or local sources. The README notes the server is now archived — "Agent Skills have been natively adopted by all major AI platforms" — making this an early MCP-bridge experiment rather than an active project.

differs_from_seeds: Closest to ccmemory (Archetype 3: MCP-anchored toolserver), but where ccmemory provides a graph-memory backend, claude-skills-mcp provides a semantic-search index over skill markdown files. Unlike taskmaster-ai (also MCP-anchored), it has no workflow orchestration and no task tracking — it is purely a discovery/retrieval layer. Unlike all 11 seeds, it ships a split two-binary architecture (proxy + backend) to work around MCP client timeout constraints.

Overview

Claude Skills MCP Server — Overview

Origin

Created by K-Dense AI (creators of autonomous AI scientists for scientific research). The project was built to solve a specific portability problem: Anthropic's Agent Skills format was initially Claude Code-native, but developers using Cursor, Codex, GPT-5, and Gemini had no way to consume the same skills library. The MCP server was the bridge.

The project has since been archived with this note:

"This MCP server is no longer hosted or maintained. Agent Skills have been natively adopted by all major AI platforms — Cursor, Windsurf, Claude Code, Copilot, and others now support skills out of the box. There is no longer a need for an MCP bridge to deliver skills to your coding assistant."

Philosophy

The project implements the progressive disclosure architecture Anthropic described in their Agent Skills engineering blog. Skills are indexed as vector embeddings; only names and descriptions load at startup. Full skill content (scripts, references, assets) is fetched on demand by calling read_skill_document. This minimizes context pollution.

The engineering philosophy is:

Zero configuration for end users — runs out of the box with curated defaults
No API keys — local vector search, GitHub caching
Multi-source — loads from any GitHub repository or local directory
Timeout-resilient — two-package split ensures the MCP registration step (list_tools) completes in under 5 seconds even on cold start

Architecture Note

The README explicitly cites the Anthropic engineering blog on "progressive disclosure" as the design inspiration. The backend uses PyTorch sentence-transformers for embedding and FAISS/HNSW-style retrieval. The frontend is a pure MCP stdio proxy that hardcodes tool schemas (so Cursor sees tools instantly) and forwards actual calls to the backend over streamable HTTP on localhost:8765.

Architecture

Claude Skills MCP Server — Architecture

Distribution

PyPI packages: claude-skills-mcp (frontend, ~15 MB) and claude-skills-mcp-backend (~250 MB, auto-installed by frontend)
Install: uvx claude-skills-mcp (one-liner) or add to ~/.cursor/mcp.json
Runtime: Python 3.12 only (requires-python = ">=3.12,<3.13")
License: Apache-2.0

Directory Structure

claude-skills-mcp/
├── packages/
│   ├── frontend/             # claude-skills-mcp PyPI package (~15 MB)
│   │   └── src/claude_skills_mcp/
│   │       ├── server.py      # Entry point
│   │       ├── mcp_proxy.py   # stdio MCP server + HTTP client bridge
│   │       └── backend_manager.py  # Auto-download/start backend
│   └── backend/              # claude-skills-mcp-backend PyPI package (~250 MB)
│       └── src/               # Vector search, skill loader, HTTP MCP server
├── scripts/
│   ├── build-all.sh
│   ├── publish-all.sh
│   └── sync-version.py
├── tests/
├── config.example.json
├── glama.json
└── docs/
    ├── architecture.md
    ├── api.md
    ├── getting-started.md
    └── usage.md

Two-Package Architecture

Cursor / Claude Code / Any MCP Client
         │  stdio
         ▼
  [Frontend: claude-skills-mcp]   ← starts in <5 seconds, hardcodes tool schemas
         │  HTTP (localhost:8765)
         ▼
  [Backend: claude-skills-mcp-backend]  ← downloads ~250 MB on first run
         │
         ▼
  Vector Index (PyTorch sentence-transformers + HNSW)
  + GitHub skill sources (cached)

Target AI Tools

Works with any MCP-compatible client:

Cursor (primary, has 1-click install button in README)
Claude Code (supports MCP)
Any other MCP-stdio client

Required Runtime

Python 3.12 (exact — not 3.11, not 3.13)
uv or pip for installation
Internet access for first-time backend download and GitHub skill fetching
No API keys needed

Components

Claude Skills MCP Server — Components

MCP Tools (3 total)

Tool	Purpose
`find_helpful_skills`	Semantic vector search over skill library — returns ranked skills with step-by-step guidance. The description instructs clients to call this FIRST for any domain-specific task. Parameters: `task_description` (required), `top_k` (1-20, default 3), `list_documents` (default true).
`read_skill_document`	Progressive content loading — retrieves specific files (scripts, references, assets) from a named skill. Supports glob patterns (e.g. `scripts/*.py`). Never executes code.
`list_skills`	Returns complete inventory of all loaded skills — names, descriptions, source repos. For exploration and debugging.

Python Modules (frontend)

Module	Purpose
`mcp_proxy.py`	Core stdio MCP server that hardcodes TOOL_SCHEMAS for instant list_tools responses; forwards actual calls to backend over streamable HTTP
`backend_manager.py`	Detects whether backend is installed; auto-downloads `claude-skills-mcp-backend` via pip if absent; starts backend process and waits for it to be ready
`server.py`	Entry point — CLI argument parsing, config loading, orchestrates proxy + manager startup
`__main__.py`	`python -m claude_skills_mcp` entrypoint

Scripts

Script	Purpose
`build-all.sh`	Build both frontend and backend packages
`publish-all.sh`	Publish both packages to PyPI
`sync-version.py`	Keep version numbers in sync across both packages

Config (`config.example.json`)

Customizable fields:

skill_sources: list of GitHub repos or local directories to load skills from
embedding_model: sentence-transformers model name
content_limits: max tokens per skill doc
cache_dir: local GitHub cache path

Default Skill Sources

anthropics/skills — Anthropic's official skills repository (~30+ skills)
K-Dense-AI/claude-scientific-skills — K-Dense AI's scientific skills (~125+ skills)

Total at default config: ~90 skills (README states ~90; K-Dense scientific repo claims 125+).

Prompts

Claude Skills MCP Server — Prompts

This is an MCP server, not a skill/command pack. Prompt content lives in the tool descriptions that are injected into AI clients. Below are the verbatim tool description strings from mcp_proxy.py.

Tool Description 1: `find_helpful_skills`

Technique: Injected instruction — the tool description itself is a directive that biases the AI client's behavior.

description=(
    "Always call this tool FIRST whenever the question requires any domain-specific knowledge "
    "beyond common sense or simple recall. Use it at task start, regardless of the task and whether "
    "you are sure about the task, It performs semantic search over a curated library of proven skills "
    "and returns ranked candidates with step-by-step guidance and best practices. Do this before any "
    "searches, coding, or any other actions as this will inform you about the best approach to take."
),

Prompting technique: Imperative directive embedded in tool description. The phrase "Always call this tool FIRST" and "Do this before any searches, coding, or any other actions" is an attempt to override the AI client's default tool-selection behavior via MCP tool metadata. This is a form of meta-prompt injection via tool schema — the instruction is not in the system prompt but in the schema document that all MCP-compatible clients read.

Tool Description 2: `read_skill_document`

description=(
    "Use after finding a relevant skill to retrieve specific documents (scripts, references, assets). "
    "Supports pattern matching (e.g., 'scripts/*.py') to fetch multiple files. Returns text content or URLs "
    "and never executes code. Prefer pulling only the files you need to complete the current step."
),

Prompting technique: Progressive disclosure guidance — explicitly tells the AI to pull only needed files per step, enforcing lazy loading behavior through the tool description itself rather than system-prompt rules.

Backend Architecture Note

The backend uses sentence-transformers embeddings to convert SKILL.md descriptions into dense vectors. The find_helpful_skills tool performs cosine similarity search and returns ranked results with the SKILL.md metadata block. The actual prompt content for each skill depends on which external skill repositories are loaded (Anthropic official skills, K-Dense scientific skills, etc.).

Uniqueness

Claude Skills MCP Server — Uniqueness

differs_from_seeds

Closest seed is ccmemory (Archetype 3: MCP-anchored toolserver). Both wrap value in a bundled MCP server rather than skills/commands files. However ccmemory provides a knowledge-graph memory backend (Neo4j + vectors) for persisting what the agent knows about a project; claude-skills-mcp provides a semantic-search index over external skill repositories to help the agent discover what methodologies to use. The difference is memory-of-facts (ccmemory) vs discovery-of-know-how (claude-skills-mcp). Unlike taskmaster-ai (also MCP-Archetype 3), there is no workflow orchestration, no task decomposition, and no state-tracking — it is purely a retrieval layer. Unlike all 11 seeds, it introduces a split two-binary proxy architecture specifically to work around MCP client timeout constraints, a novel deployment engineering choice not seen elsewhere in the corpus.

Positioning

Primary value: Cross-platform skills discovery for non-Claude-Code AI clients
Now archived: Native skills support in Cursor/Windsurf eliminated the need for the MCP bridge
Scientific niche: The K-Dense scientific skills collection (125+ bioinformatics, cheminformatics, clinical research skills) gave it a unique domain beyond general software engineering

Observable Failure Modes

Backend startup latency — First run requires ~250 MB download and PyTorch model loading (~60-120 s). If the MCP client has a strict timeout, the client may fail before the backend is ready, even though the frontend responds instantly.
Python 3.12 pinning — requires-python = ">=3.12,<3.13" means users on 3.11 or 3.13 cannot use the package at all.
Tool description injection — The find_helpful_skills tool description says "Always call this tool FIRST regardless of the task." This aggressive directive may cause AI clients to call the skill discovery tool even for trivial tasks, burning latency.
Archived status — The project is effectively deprecated. The README states it is "no longer hosted or maintained."

Cross-References

Indexes skills from anthropics/skills and K-Dense-AI/claude-scientific-skills
Inspired by Anthropic's progressive disclosure architecture (cited in README)
Registered on Glama.ai MCP directory

Workflow

Claude Skills MCP Server — Workflow

User Workflow

This is a discovery-and-retrieval server, not a multi-phase workflow framework. The workflow is:

Install — uvx claude-skills-mcp or add to MCP client config
Cold start — Frontend starts in <5 s; backend downloads (~60-120 s, one-time)
Task begins — AI client calls find_helpful_skills with task description
Ranked results — Server returns top-k skills with metadata and document list
Progressive load — AI client calls read_skill_document to fetch specific scripts/references as needed
Task execution — AI uses skill content to guide its work

Phase-to-Artifact Map

Phase	Artifact
Skill discovery	Ranked skill list with descriptions + doc inventory
Content retrieval	Full SKILL.md text, scripts, reference files
Inventory exploration	Complete catalog via `list_skills`

Approval Gates

None — this is a pure retrieval server. No approval gates, no workflow orchestration.

Configuration Workflow

# 1. Print default config
uvx claude-skills-mcp --example-config > config.json

# 2. Edit config.json to add custom skill sources or change embedding model

# 3. Run with custom config
uvx claude-skills-mcp --config config.json

Backend Lifecycle

Frontend starts (stdio MCP, <5s)
  ↓ check: is backend installed?
  ↓ NO: pip install claude-skills-mcp-backend (background)
  ↓ start backend process on localhost:8765
  ↓ wait for /health endpoint to respond
Backend ready (~60-120s first time, instant thereafter)
  ↓ Index loaded from GitHub cache + local directories
  ↓ Vector embeddings computed
Server ready for queries

Memory Context

Claude Skills MCP Server — Memory & Context

State Storage

The server itself is stateless from a conversation perspective. It maintains:

GitHub cache — locally cached copies of skill repositories to avoid repeated GitHub API calls. Location: configurable via cache_dir in config.json.
Vector index — PyTorch sentence-transformer embeddings computed at startup and held in memory. Not persisted to disk between runs (re-computed on each backend start from cached source files).

Memory Type

file-based — skill content lives as markdown files in GitHub repos, pulled and cached locally
in-memory vector index — embeddings are held in RAM during the backend process lifetime

Persistence

Session-only — the vector index lives in RAM for the duration of the backend process
Project — the GitHub cache persists on disk for faster subsequent starts

Context Compaction

Not applicable — this is a retrieval server. It does not participate in Claude Code session compaction or cross-session handoffs.

Progressive Disclosure Pattern

The architecture explicitly implements Anthropic's progressive disclosure recommendation:

On list_skills: return names + short descriptions only (low token cost)
On find_helpful_skills: return ranked results with metadata + document list (medium cost)
On read_skill_document: return full file content on demand (high cost, only when needed)

This mirrors the three-level progressive disclosure described in muratcankoylan's context-fundamentals skill — load summaries at startup, load full content only when activated.

Orchestration

Claude Skills MCP Server — Orchestration

Multi-Agent

No. This is a single MCP server with no agent spawning, orchestration patterns, or subagent definitions.

Orchestration Pattern

None — pure retrieval service. The "orchestration" pattern is: AI client calls find_helpful_skills → receives ranked skill list → optionally calls read_skill_document. One tool call at a time.

Isolation Mechanism

Not applicable. The server runs as a local process; it does not isolate agent work.

Multi-Model

No. The server has no concept of model routing. It serves any MCP-compatible client regardless of the underlying model.

Execution Mode

Event-driven (MCP tool calls). The backend is a long-running HTTP process that the frontend proxy connects to; each tool call is a short HTTP request. The server itself is stateless between calls.

Process Architecture

MCP Client (Cursor, etc.)
  ↓ stdio
Frontend process (claude-skills-mcp)  [always running]
  ↓ HTTP localhost:8765
Backend process (claude-skills-mcp-backend)  [started by frontend, long-running]
  ↓ in-memory
Vector index + GitHub cache

Crash Recovery

Partial. The frontend catches backend failures and attempts to restart it. No explicit crash-recovery protocol documented.

Consensus Mechanism

None.

Prompt Chaining

No — each tool call is independent.

Ui Cli Surface

Claude Skills MCP Server — UI & CLI Surface

CLI Binary

Yes — claude-skills-mcp is the binary name (registered via pyproject.toml entry points).

Subcommands / flags:

uvx claude-skills-mcp — start with default config
uvx claude-skills-mcp --example-config — print default config to stdout
uvx claude-skills-mcp --config <path> — run with custom config
uvx claude-skills-mcp --verbose — verbose logging

The backend binary (claude-skills-mcp-backend) exposes:

--port <int> — listen port (default 8765)
--host <str> — bind host (default localhost)
--config <path> — custom config
--verbose — verbose logging
--example-config — print default config

Local UI

No web dashboard, no TUI. The server's "UI" is the MCP tool interface as seen by the AI client.

IDE Integration

Cursor: 1-click install via Cursor Directory deeplink button in README
Claude Code: Manual add to MCP config (claude mcp add)
Any MCP-compatible client via stdio

Observability

Verbose logging flag on both frontend and backend processes
No structured audit log
No metrics endpoint
The list_skills tool acts as a debugging/inventory tool for operators

Transport

Frontend ↔ Client: stdio (MCP standard)
Frontend ↔ Backend: streamable HTTP (MCP protocol over HTTP)
Backend port: 8765 (default, configurable)

Related frameworks

same archetype · same primary tool · same memory type

Taskmaster AI ★ 27k

A3 MCP-anchored

Converts a PRD into a dependency-ordered JSON task graph that AI coding agents execute one task at a time, eliminating context…

ccmemory ★ 1

A3 MCP-anchored

Accumulates decisions, corrections, and failed approaches from Claude Code sessions into a queryable Neo4j graph so each new…

Pimzino spec-workflow-mcp ★ 4.2k

A3 MCP-anchored

MCP server providing spec-driven development workflow with dashboard-backed approval gates, implementation logging, and VSCode…

MCP Shrimp Task Manager ★ 2.1k

A3 MCP-anchored

Convert natural language requests into structured AI development tasks with chain-of-thought enforcement, reflection gates, and…

Bernstein ★ 460

A3 MCP-anchored

Govern parallel CLI coding agents with a deterministic Python scheduler, HMAC-chained audit trail, and compliance-ready signed…

LeanSpec ★ 252

A3 MCP-anchored

Provides a unified spec CLI and MCP server over any existing spec backend (markdown, GitHub Issues, ADO), making spec-driven…

Distribution

Type: mcp-server
License: Apache-2.0
Install: one-liner
Version: 1.0.6

Surfaces

CLI binary: claude-skills-mcp
CLI subcmds: 4
Local UI: No
Tech stack: none

Components

Commands: 0
Skills: 0
Subagents: 0
Hooks: 0
MCP servers: 2
MCP tools: 3
Scripts: 3
Templates: 1

Workflow

Phases: 3
Approval gates: 0
Spec format: none
Spec storage: none
Delta or full: none

Orchestration

Multi-agent: No
Pattern: none
Max concurrent: 1
Isolation: none
Consensus: none
Prompt chaining: No

Multi-model

Multi-model: No
BYOK: Yes
Modal: text

Execution

Mode: event-driven
Crash recovery: No
Compaction: No
Session handoff: No
Streaming: No

Memory

Type: file-based
Persistence: project
Search: vector
State files: 2 files

Quality

TDD: No
TDD mechanism: none
Self-review: none

Git / Observability

Auto commit: No
Auto PR: No
Auto merge: No
Worktree/feat: No
Audit log: No
Audit format: none
Replay: No

Tools

Primary: cursor
Targets: 3
Portability: high

Signals

Stars: 387
Last commit: 2026-04-08
Contributors: 2
Maintainer: archived
Quality score: 0/10

Summary

Claude Skills MCP Server — Summary

Overview

Claude Skills MCP Server — Overview

Origin

Philosophy

Architecture Note

Architecture

Claude Skills MCP Server — Architecture

Distribution

Directory Structure

Two-Package Architecture

Target AI Tools

Required Runtime

Components

Claude Skills MCP Server — Components

MCP Tools (3 total)

Python Modules (frontend)

Scripts

Config (config.example.json)

Default Skill Sources

Prompts

Claude Skills MCP Server — Prompts

Tool Description 1: find_helpful_skills

Tool Description 2: read_skill_document

Backend Architecture Note

Uniqueness

Claude Skills MCP Server — Uniqueness

differs_from_seeds

Positioning

Observable Failure Modes

Cross-References

Workflow

Claude Skills MCP Server — Workflow

User Workflow

Phase-to-Artifact Map

Approval Gates

Configuration Workflow

Backend Lifecycle

Memory Context

Claude Skills MCP Server — Memory & Context

State Storage

Memory Type

Persistence

Context Compaction

Progressive Disclosure Pattern

Orchestration

Claude Skills MCP Server — Orchestration

Multi-Agent

Orchestration Pattern

Isolation Mechanism

Multi-Model

Execution Mode

Process Architecture

Crash Recovery

Consensus Mechanism

Prompt Chaining

Ui Cli Surface

Claude Skills MCP Server — UI & CLI Surface

CLI Binary

Local UI

IDE Integration

Observability

Transport

Related frameworks

Config (`config.example.json`)

Tool Description 1: `find_helpful_skills`

Tool Description 2: `read_skill_document`