Svelte MCP server

Tools provided by Svelte 4

Some details were sanitized for public display.

• get-documentationNo outputSchema

  Retrieves full documentation content for Svelte 5 or SvelteKit sections. Supports flexible search by title (e.g., "$state", "routing") or file path (e.g., "cli/overview"). Can accept a single section name or an array of sections. Before running this, make sure to analyze the users query, as well as the output from list-sections (which should be called first). Then ask for ALL relevant sections the user might require. For example, if the user asks to build anything interactive, you will need to fetch all relevant runes, and so on. Before calling this tool, try to implement Svelte components usi

  Input section: any

  • section: anyrequired

    The section name(s) to retrieve. Can search by title (e.g., "$state", "load functions") or file path (e.g., "cli/overview"). Supports single string and array of strings

• list-sectionsNo outputSchema

  Lists all available Svelte 5 and SvelteKit documentation sections in a structured format. Each section includes a "use_cases" field that describes WHEN this documentation would be useful. You should carefully analyze the use_cases field to determine which sections are relevant for the user's query. The use_cases contain comma-separated keywords describing project types (e.g., "e-commerce", "blog"), features (e.g., "authentication", "forms"), components (e.g., "slider", "modal"), development stages (e.g., "deployment", "testing"), or "always" for fundamental concepts. Match these use_cases agai

  Input No parameters

• playground-linkoutputSchema declared

  Generates a Playground link given a Svelte code snippet. Once you have the final version of the code you want to send to the user, ALWAYS ask the user if it wants a playground link to allow it to quickly check the code in the playground before calling this tool. NEVER use this tool if you have written the component to a file in the user project. The playground accept multiple files so if are importing from other files just include them all at the root level.

  Input files: object, name: string, tailwind: boolean

  • files: objectrequired

    An object where all the keys are the filenames (with extensions) and the values are the file content. For example: { 'Component.svelte': '<script>...</script>', 'utils.js': 'export function ...' }. The playground accept multiple files so if are importing from other files just include them all at the root level.

  • name: stringrequired

    The name of the Playground, it should reflect the user task

  • tailwind: booleanrequired

    If the code requires Tailwind CSS to work...only send true if it it's using tailwind classes in the code

• svelte-autofixeroutputSchema declared

  Given a svelte component or module returns a list of suggestions to fix any issues it has. This tool MUST be used whenever the user is asking to write svelte code before sending the code back to the user

  Input async?: boolean, code: string, desired_svelte_version: any, filename?: string

  • async?: booleanoptional

    If true the code is an async component/module and might use await in the markup or top-level awaits in the script tag. If possible check the svelte.config.js/svelte.config.ts to check if the option is enabled otherwise asks the user if they prefer using it or not. You can only use this option if the version is 5.

  • code: stringrequired
  • desired_svelte_version: anyrequired

    The desired svelte version as a full semver string (e.g. "5.16.0", the major MUST be 4 or 5)...you MUST read this from the package.json of the user project (or from the installed node_modules/svelte/package.json) since some suggestions are only enabled for newer versions. If you can't find it use some hint from the wording (if the user asks for runes it wants version 5) and pass only the major. Default to 5 in case of doubt.

  • filename?: stringoptional

    The filename of the component if available, it MUST be only the Component name with .svelte or .svelte.ts extension and not the entire path.

Resources 204

100 of 204 shown; 104 omitted to keep the page bounded.

• ai/claude-plugin

  Claude Code — use title and path to estimate use case

• ai/cli

  CLI — use title and path to estimate use case

• ai/codex-plugin

  Codex CLI — use title and path to estimate use case

• ai/copilot-plugin

  GitHub Copilot CLI — use title and path to estimate use case

• ai/cursor-plugin

  Cursor — use title and path to estimate use case

• ai/instructions

  AGENTS.md — use title and path to estimate use case

• ai/local-setup

  Local setup — use title and path to estimate use case

• ai/mcp

  Overview — use title and path to estimate use case

• ai/opencode-plugin

  OpenCode — use title and path to estimate use case

• ai/overview

  Overview — use title and path to estimate use case

• ai/prompts

  Prompts — use title and path to estimate use case

• ai/remote-setup

  Remote setup — use title and path to estimate use case

• ai/resources

  Resources — use title and path to estimate use case

• ai/skills

  Overview — use title and path to estimate use case

• ai/subagent

  Overview — use title and path to estimate use case

• ai/tools

  Tools — use title and path to estimate use case

• cli/ai-tools

  ai-tools — use title and path to estimate use case

• cli/better-auth

  better-auth — use title and path to estimate use case

• cli/community

  [create your own] — use title and path to estimate use case

• cli/drizzle

  drizzle — database setup, sql queries, orm integration, data modeling, postgresql, mysql, sqlite, server-side data access, database migrations, type-safe queries

• cli/enhanced-img

  enhanced-img — use title and path to estimate use case

• cli/eslint

  eslint — code quality, linting, error detection, project setup, code standards, team collaboration, typescript projects

• cli/experimental

  experimental — use title and path to estimate use case

• cli/faq

  Frequently asked questions — project setup, initializing new svelte projects, troubleshooting cli installation, package manager configuration

• cli/mdsvex

  mdsvex — blog, content sites, markdown rendering, documentation sites, technical writing, cms integration, article pages

• cli/overview

  Overview — project setup, creating new svelte apps, scaffolding, cli tools, initializing projects

• cli/paraglide

  paraglide — internationalization, multi-language sites, i18n, translation, localization, language switching, global apps, multilingual content

• cli/playwright

  playwright — browser testing, e2e testing, integration testing, test automation, quality assurance, ci/cd pipelines, testing user flows

• cli/prettier

  prettier — code formatting, project setup, code style consistency, team collaboration, linting configuration

• cli/storybook

  storybook — component development, design systems, ui library, isolated component testing, documentation, visual testing, component showcase

• cli/sv

  sv — use title and path to estimate use case

• cli/sv-add

  sv add — project setup, adding features to existing projects, integrating tools, testing setup, styling setup, authentication, database setup, deployment adapters

• cli/sv-check

  sv check — code quality, ci/cd pipelines, error checking, typescript projects, pre-commit hooks, finding unused css, accessibility auditing, production builds

• cli/sv-create

  sv create — project setup, starting new sveltekit app, initializing project, creating from playground, choosing project template

• cli/sv-migrate

  sv migrate — migration, upgrading svelte versions, upgrading sveltekit versions, modernizing codebase, svelte 3 to 4, svelte 4 to 5, sveltekit 1 to 2, adopting runes, refactoring deprecated apis

• cli/sv-utils

  sv-utils — use title and path to estimate use case

• cli/sveltekit-adapter

  sveltekit-adapter — deployment, production builds, hosting setup, choosing deployment platform, configuring adapters, static site generation, node server, vercel, cloudflare, netlify

• cli/tailwind

  tailwindcss — project setup, styling, css framework, rapid prototyping, utility-first css, design systems, responsive design, adding tailwind to svelte

• cli/vitest

  vitest — testing, unit tests, component testing, test setup, quality assurance, ci/cd pipelines, test-driven development

• kit/@sveltejs-kit

  @sveltejs/kit — forms, form actions, server-side validation, form submission, error handling, redirects, json responses, http errors, server utilities

• kit/@sveltejs-kit-adapter

  @sveltejs/kit/adapter — use title and path to estimate use case

• kit/@sveltejs-kit-env

  @sveltejs/kit/env — use title and path to estimate use case

• kit/@sveltejs-kit-hooks

  @sveltejs/kit/hooks — middleware, request processing, authentication chains, logging, multiple hooks, request/response transformation

• kit/@sveltejs-kit-node

  @sveltejs/kit/node — node.js adapter, custom server setup, http integration, streaming files, node deployment, server-side rendering with node

• kit/@sveltejs-kit-params

  @sveltejs/kit/params — use title and path to estimate use case

• kit/@sveltejs-kit-vite

  @sveltejs/kit/vite — project setup, vite configuration, initial sveltekit setup, build tooling

• kit/$app-env

  $app/env — use title and path to estimate use case

• kit/$app-env-private

  $app/env/private — use title and path to estimate use case

• kit/$app-env-public

  $app/env/public — use title and path to estimate use case

• kit/$app-environment

  $app/environment — always, conditional logic, client-side code, server-side code, build-time logic, prerendering, development vs production, environment detection

• kit/$app-forms

  $app/forms — forms, user input, data submission, progressive enhancement, custom form handling, form validation

• kit/$app-manifest

  $app/manifest — use title and path to estimate use case

• kit/$app-navigation

  $app/navigation — routing, navigation, multi-page apps, programmatic navigation, data reloading, preloading, shallow routing, navigation lifecycle, scroll handling, view transitions

• kit/$app-paths

  $app/paths — static assets, images, fonts, public files, base path configuration, subdirectory deployment, cdn setup, asset urls, links, navigation

• kit/$app-server

  $app/server — remote functions, server-side logic, data fetching, form handling, api endpoints, client-server communication, prerendering, file reading, batch queries

• kit/$app-service-worker

  $app/service-worker — use title and path to estimate use case

• kit/$app-state

  $app/state — routing, navigation, multi-page apps, loading states, url parameters, form handling, error states, version updates, page metadata, shallow routing

• kit/$app-stores

  $app/stores — legacy projects, sveltekit pre-2.12, migration from stores to runes, maintaining older codebases, accessing page data, navigation state, app version updates

• kit/$app-tsconfig

  $app/tsconfig — use title and path to estimate use case

• kit/$app-tsconfig-service-worker

  $app/tsconfig/service-worker — use title and path to estimate use case

• kit/$app-types

  $app/types — routing, navigation, type safety, route parameters, dynamic routes, link generation, pathname validation, multi-page apps

• kit/$env-dynamic-private

  $env/dynamic/private — api keys, secrets management, server-side config, environment variables, backend logic, deployment-specific settings, private data handling

• kit/$env-dynamic-public

  $env/dynamic/public — environment variables, client-side config, runtime configuration, public api keys, deployment-specific settings, multi-environment apps

• kit/$env-static-private

  $env/static/private — server-side api keys, backend secrets, database credentials, private configuration, build-time optimization, server endpoints, authentication tokens

• kit/$env-static-public

  $env/static/public — environment variables, public config, client-side data, api endpoints, build-time configuration, public constants

• kit/$lib

  #lib — project setup, component organization, importing shared components, reusable ui elements, code structure

• kit/$service-worker

  $service-worker — offline support, pwa, service workers, caching strategies, progressive web apps, offline-first apps

• kit/accessibility

  Accessibility — always, any sveltekit project, screen reader support, keyboard navigation, multi-page apps, client-side routing, internationalization, multilingual sites

• kit/adapter-auto

  Zero-config deployments — deployment, production builds, hosting setup, choosing deployment platform, ci/cd configuration

• kit/adapter-bun

  Bun servers — use title and path to estimate use case

• kit/adapter-cloudflare

  Cloudflare — deployment, cloudflare workers, cloudflare pages, hosting setup, production builds, serverless deployment, edge computing

• kit/adapter-cloudflare-workers

  Cloudflare Workers — deploying to cloudflare workers, cloudflare workers sites deployment, legacy cloudflare adapter, wrangler configuration, cloudflare platform bindings

• kit/adapter-netlify

  Netlify — deployment, netlify hosting, production builds, serverless functions, edge functions, static site hosting

• kit/adapter-node

  Node servers — deployment, production builds, node.js hosting, custom server setup, environment configuration, reverse proxy setup, docker deployment, systemd services

• kit/adapter-static

  Static site generation — static site generation, ssg, prerendering, deployment, github pages, spa mode, blogs, documentation sites, marketing sites

• kit/adapter-vercel

  Vercel — deployment, vercel hosting, production builds, serverless functions, edge functions, isr, image optimization, environment variables

• kit/adapters

  Adapters — deployment, production builds, hosting setup, choosing deployment platform, configuring adapters

• kit/additional-resources

  Additional resources — troubleshooting, getting help, finding examples, learning sveltekit, project templates, common issues, community support

• kit/advanced-routing

  Advanced routing — advanced routing, dynamic routes, file viewers, nested paths, custom 404 pages, url validation, route parameters, multi-level navigation

• kit/auth

  Auth — authentication, login systems, user management, session handling, jwt tokens, protected routes, user credentials, authorization checks

• kit/building-your-app

  Building your app — production builds, deployment preparation, build process optimization, adapter configuration, preview before deployment

• kit/cli

  Command Line Interface — project setup, typescript configuration, generated types, ./$types imports, initial project configuration

• kit/creating-a-project

  Creating a project — project setup, starting new sveltekit app, initial development environment, first-time sveltekit users, scaffolding projects

• kit/debugging

  Breakpoint Debugging — debugging, breakpoints, development workflow, troubleshooting issues, vscode setup, ide configuration, inspecting code execution

• kit/environment-variables

  Environment variables — use title and path to estimate use case

• kit/errors

  Errors — error handling, custom error pages, 404 pages, api error responses, production error logging, error tracking, type-safe errors

• kit/faq

  Frequently asked questions — troubleshooting package imports, library compatibility issues, client-side code execution, external api integration, middleware setup, database configuration, view transitions, yarn configuration

• kit/form-actions

  Form actions — forms, user input, data submission, authentication, login systems, user registration, progressive enhancement, validation errors

• kit/glossary

  Glossary — rendering strategies, performance optimization, deployment configuration, seo requirements, static sites, spas, server-side rendering, prerendering, edge deployment, pwa development

• kit/hooks

  Hooks — authentication, logging, error tracking, request interception, api proxying, custom routing, internationalization, database initialization, middleware logic, session management

• kit/icons

  Icons — icons, ui components, styling, css frameworks, tailwind, unocss, performance optimization, dependency management

• kit/images

  Images — image optimization, responsive images, performance, hero images, product photos, galleries, cms integration, cdn setup, asset management

• kit/integrations

  Integrations — project setup, css preprocessors, postcss, scss, sass, less, stylus, typescript setup, adding integrations, tailwind, testing, auth, linting, formatting

• kit/introduction

  Introduction — learning sveltekit, project setup, understanding framework basics, choosing between svelte and sveltekit, getting started with full-stack apps

• kit/link-options

  Link options — routing, navigation, multi-page apps, performance optimization, link preloading, forms with get method, search functionality, focus management, scroll behavior

• kit/load

  Loading data — data fetching, api calls, database queries, dynamic routes, page initialization, loading states, authentication checks, ssr data, form data, content rendering

• kit/migrating

  Migrating from Sapper — migrating from sapper, upgrading legacy projects, sapper to sveltekit conversion, project modernization

• kit/migrating-to-sveltekit-2

  Migrating to SvelteKit v2 — migration, upgrading from sveltekit 1 to 2, breaking changes, version updates

• kit/migrating-to-sveltekit-3

  Migrating to SvelteKit v3 — use title and path to estimate use case

• kit/observability

  Observability — performance monitoring, debugging, observability, tracing requests, production diagnostics, analyzing slow requests, finding bottlenecks, monitoring server-side operations

Resource templates 1

• Svelte-Doc-Section

  A single documentation section — A single documentation section

Prompts 1

• svelte-task

  Use this Prompt to ask for any svelte related task. It will automatically instruct the LLM on how to best use the autofixer and how to query for documentation pages.

  Arguments task: any

  • task: anyrequired

    The task to be performed