skeleton-svelte-mcp
Provides Svelte-oriented documentation guidance for the Skeleton UI library, including searching official docs and retrieving full sections relevant to Svelte usage.
Click on "Install 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., "@skeleton-svelte-mcpSearch Skeleton docs for Svelte accordion usage"
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.
Skeleton Svelte MCP
A local, stdio MCP server that gives coding agents searchable access to the official Skeleton documentation, with a focus on Svelte usage.
What it provides
search_skeleton_docs: ranked official documentation sections for a task or API query.get_skeleton_section: a full named section, such asAccordionorInstallation.skeleton_svelte_guidance: Svelte-oriented excerpts for an implementation task.skeleton://documentation/full: the complete official documentation as an MCP resource.
Documentation is retrieved only from Skeleton's published llms-full.txt, kept in memory for one hour, and refreshed after that. If a refresh fails, the last successful copy remains available for the process lifetime.
Related MCP server: @particle-academy/docs-mcp
Install and build
Requires Node.js 20 or later.
npm install
npm run buildCodex configuration
Add this server to your Codex MCP configuration, replacing {base-folder} with the directory containing this project:
[mcp_servers.skeleton-svelte]
command = "node"
args = ["{base-folder}\\dist\\index.js"]For development, use npx tsx {base-folder}\\src\\index.ts as the command and arguments instead.
The server uses stdout exclusively for MCP JSON-RPC; operational logs must go to stderr.
Run directly from GitHub
The compiled dist/ folder is intentionally committed, so Codex can download and run a tagged GitHub release without a local clone. Create and push a Git tag that matches the release, for example:
git tag v0.1.1
git push origin v0.1.1Then configure Codex to install and run that immutable release through npx:
[mcp_servers.skeleton-svelte]
command = "npx"
args = [
"--allow-git=all",
"--yes",
"--package=github:mxmauro/mcp-skeleton-dev#v0.1.1",
"skeleton-svelte-mcp"
]v0.1.1 is a Git tag, not merely the version value in package.json. Every tagged release must include package.json, package-lock.json, and a freshly built dist/ directory. Node.js, npm, GitHub access, and network access are required on the machine where Codex starts the server.
License
Licensed under the MIT License. Copyright (c) 2026 Mauro H. Leggieri.
Available Tools
3 toolsget_skeleton_sectionGet a Skeleton documentation sectionA
Returns a specific official Skeleton documentation section by its top-level title, such as "Accordion", "Installation", or "Themes".
| Name | Required | Description | Default |
|---|---|---|---|
| title | Yes | Top-level documentation title; matching is case-insensitive |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the responsibility for behavioral disclosure. It accurately states the core read behavior and title-based scoping. However, it does not describe the return format, behavior when a title is not found, or whether the returned section contains nested content. The description is adequate but not rich.
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 a single, front-loaded sentence that states the operation, the resource, and illustrative examples. There is no wasted wording, and it is appropriately sized for a simple one-parameter retrieval tool.
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?
For a tool with one required parameter and no output schema, the description covers the essential selection and invocation needs: what it returns and how to identify the section. The only minor gap is the lack of explicit detail about the returned content or error behavior, but this does not block correct invocation.
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 input schema fully describes the title parameter and its case-insensitivity, so the baseline is 3. The description adds value by giving concrete examples of top-level titles ('Accordion', 'Installation', 'Themes'), which helps the agent understand what counts as a valid input.
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 uses a specific verb ('Returns') and a specific resource ('official Skeleton documentation section') qualified by top-level title. Concrete examples like 'Accordion', 'Installation', and 'Themes' make the tool's scope unmistakable and clearly distinguish it from the search-oriented sibling.
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 clearly implies when to use this tool: when you need a specific Skeleton documentation section identified by its exact top-level title. It does not explicitly contrast with search_skeleton_docs or skeleton_svelte_guidance, but the 'specific section by title' framing gives clear context without exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_skeleton_docsSearch Skeleton documentationA
Searches the official Skeleton documentation and returns the most relevant top-level sections. Use for Svelte components, Tailwind utility classes, themes, installation, or APIs.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum matching sections to return | |
| query | Yes | What you need to learn, e.g. "Svelte dialog controlled state" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden, and it clearly says the tool searches official documentation and returns the most relevant top-level sections. It does not discuss external network access or detail limits beyond what the schema already states, but for a read-only search tool the behavior is sufficiently disclosed.
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 two sentences with no filler. The action and result are front-loaded, followed by a compact list of intended use cases. Every sentence earns its place.
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?
For a simple search tool with fully documented parameters, the description is nearly complete: it states the resource, return type, and use cases. It could be improved by explaining how it relates to get_skeleton_section and skeleton_svelte_guidance, but nothing essential to invoking it correctly is missing.
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 description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond the schema, but the schema already explains query examples and the limit's min/max/default, so no compensation is needed.
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 verb and resource: it searches the official Skeleton documentation and returns top-level sections. It does not explicitly distinguish itself from the sibling tools, but the output type and listed topics make its purpose distinct enough for selection.
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 gives an explicit list of use cases: Svelte components, Tailwind utility classes, themes, installation, or APIs. It does not mention exclusions or alternatives like get_skeleton_section, but it provides enough context for when this search tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
skeleton_svelte_guidanceGet Svelte-oriented Skeleton guidanceA
Finds the official Skeleton documentation most relevant to a Svelte UI task and returns implementation-oriented excerpts. This does not generate unverified APIs.
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | Describe the UI task, e.g. "accessible modal with controlled open state" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It usefully states that the tool returns excerpts from official documentation and explicitly says it 'does not generate unverified APIs,' which sets accurate expectations about output reliability. It does not mention potential limitations such as excerpt length or search freshness, but the provided traits are meaningful.
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?
Two concise sentences with no filler. The core behavior is front-loaded, and the negative guarantee about not generating unverified APIs is a valuable, compact addition.
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?
For a simple one-parameter tool, the description covers what it does and what it returns (implementation-oriented excerpts). There is no output schema, but the description partially compensates by describing the return type. However, it could benefit from clarifying the exact form of the excerpts or what to do when no relevant documentation is found.
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 single 'task' parameter is fully covered by the schema, including an example. The description adds no parameter-specific detail beyond the schema, so the baseline score of 3 applies.
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's verb ('Finds'), resource ('official Skeleton documentation'), and intended scope ('most relevant to a Svelte UI task'). It distinguishes itself by emphasizing Svelte-orientation and implementation excerpts, though it does not explicitly contrast with its siblings.
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 intended use is implied: for Svelte UI tasks needing relevant official documentation excerpts. However, there is no explicit guidance about when to prefer this tool over search_skeleton_docs or get_skeleton_section, and no exclusions or alternative conditions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
3 tool updates
v0.1.1- First observed
get_skeleton_section - First observed
search_skeleton_docs - First observed
skeleton_svelte_guidance
TDQS
get_skeleton_section is clearly distinct, but search_skeleton_docs and skeleton_svelte_guidance both perform relevance-based retrieval from the same documentation. The difference between returning top-level sections and implementation-oriented excerpts is present but subtle enough that an agent could easily choose the wrong tool.
Two tools follow a clear verb_noun pattern: search_skeleton_docs and get_skeleton_section. The third, skeleton_svelte_guidance, reads as a noun phrase rather than a verb-driven action, creating a mild inconsistency in the set.
Three tools is well-scoped for a documentation-focused MCP server. Each tool has a clear function, and there is no unnecessary bloat or redundancy that would weigh down the server.
The domain is Skeleton documentation lookup, and the set covers searching, retrieving specific sections, and getting task-oriented guidance. A direct listing or browsing of all available sections is missing, but the existing tools can likely cover most documentation needs.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
The official Svelte MCP server providing docs and autofixing tools for Svelte development
An MCP server that gives your AI access to the source code and docs of all public github repos
Agent-native MCP server over the public saagarpatel.dev corpus. Read-only, stateless.
MCP server for agentverse documentation, generated by doc2mcp.
Related MCP Servers
- AlicenseCqualityDmaintenanceEnables vector similarity search and serving of Svelte documentation via the MCP protocol, with support for local caching and multiple llms.txt documentation formats.1855123MIT
- AlicenseAqualityCmaintenanceA dev-time MCP server that lets coding agents read documentation directly from installed @particle-academy/\* packages, ensuring version-matched docs without network calls.522MIT
- AlicenseAqualityBmaintenanceA local MCP server that fetches official library documentation (llms.txt-first), caches it to disk, and serves relevant sections to coding agents offline with deterministic retrieval.34MIT
- FlicenseNot gradedqualityBmaintenanceLocal MCP server that indexes documentation from URLs/files into a vector database, enabling coding agents to search and use up-to-date library and API documentation.-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/mxmauro/mcp-skeleton-dev'
If you have feedback or need assistance with the MCP directory API, please join our Discord server