Salt MCP
Provides tools and guidelines for building applications using the Salt Design System, JP Morgan Chase's open-source React component library.
Enables converting Figma design descriptions or screenshots into Salt Design System code via specialized agent skills.
Supports building applications using the Salt Design System's library of React components, usage guidelines, and accessibility rules.
Provides access to Storybook example code for Salt Design System components to help agents generate accurate UI code.
Exposes TypeScript prop interfaces for Salt components, ensuring type-safe implementation and accurate property usage.
Includes skills for scaffolding new Salt Design System applications configured with Vite.
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., "@Salt MCP show me the props and a code example for the Salt Button component"
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.
Salt MCP
An MCP server and Agent Skills for building applications with the Salt Design System — JP Morgan Chase's open-source React component library.
What it does
This project gives AI agents access to Salt DS knowledge so they can help you build Salt applications accurately, using the right components, props, patterns, and best practices — instead of guessing.
MCP Tools let agents look things up on the fly:
Component APIs, props, and examples
Usage guidelines and accessibility rules
Design patterns (forms, navigation, search, etc.)
Foundations (density, spacing, color, typography)
Agent Skills give agents step-by-step instructions for common tasks:
Scaffolding a new Salt app
Building page layouts
Creating forms
Implementing UI patterns
Converting Figma designs to Salt code
Related MCP server: react-devtools-mcp
Prerequisites
Node.js (v18+)
An MCP-compatible client or an agent that supports the Agent Skills standard (e.g. VS Code with GitHub Copilot, Claude Code, Cursor, Gemini CLI, Windsurf)
A local clone of the Salt DS repository:
git clone --depth 1 https://github.com/jpmorganchase/salt-ds.git ~/Code/salt-ds
Setup
# Clone this repo
git clone https://github.com/feesch/salt-mcp.git
cd salt-mcp
# Install dependencies
npm install
# Build
npm run buildRegister the MCP server
The repo includes a .mcp.json file that Claude Code and some other clients auto-discover. For other clients, configure the server manually:
Create or edit .vscode/mcp.json in your project:
{
"servers": {
"salt-mcp": {
"type": "stdio",
"command": "node",
"args": ["/absolute/path/to/salt-mcp/build/index.js"]
}
}
}Replace /absolute/path/to/salt-mcp with the actual path where you cloned this repo. Then open Copilot Chat in Agent mode to use the tools.
The .mcp.json file in the repo root is auto-discovered — no extra config needed. Alternatively, add to your project's .claude/settings.json:
{
"mcpServers": {
"salt-mcp": {
"command": "node",
"args": ["./build/index.js"]
}
}
}Add to your client's MCP configuration:
{
"mcpServers": {
"salt-mcp": {
"command": "node",
"args": ["/absolute/path/to/salt-mcp/build/index.js"]
}
}
}Refer to your client's documentation for the config file location.
Install the skills
Copy the skills/ directory into the location your agent expects:
Claude Code: Copy into
.claude/skills/in your project or home directoryCursor: Copy into
.cursor/skills/VS Code / GitHub Copilot: Skills are not yet natively supported — use the MCP tools directly, or paste skill content into your Copilot Chat prompt as instructions
Other agents: See your agent's documentation for the skills directory
Skills follow the open Agent Skills standard and work with any compatible agent.
MCP Tools
Tool | Description |
| Test that the server is running |
| List all Salt components (core, lab, or both) |
| Get the TypeScript props interface for a component |
| Get Storybook example code for a component |
| Search components by keyword |
| Get usage guidelines, accessibility rules, patterns, and foundations |
Skills
Skills are portable instruction sets that guide agents through multi-step tasks. They follow the Agent Skills standard.
Skill | Description |
| Scaffold a new React app with Salt DS (SaltProvider, theme, Vite) |
| Build page layouts using Salt layout components |
| Build forms following Salt's form pattern |
| Build any of 20+ Salt UI patterns (search, navigation, wizard, etc.) |
| Convert a Figma design (screenshot or description) into Salt code |
Keeping Salt DS up to date
The MCP tools read from your local Salt DS clone at runtime, so they automatically reflect any updates. Skills contain some static mapping tables but always instruct agents to verify via the tools.
To pull the latest Salt DS changes:
git -C ~/Code/salt-ds pullNo rebuild of salt-mcp is needed — the tools will return updated data immediately.
Development
npm run build # Compile TypeScript
npm test # Run unit tests (37 tests via Vitest)
npm run test:watch # Run tests in watch modeProject structure
salt-mcp/
src/
index.ts # MCP server with tools
helpers.ts # Shared helpers and security functions
helpers.test.ts # Unit tests (Vitest)
skills/ # Agent Skills (agentskills.io standard)
salt-app/SKILL.md
salt-page/SKILL.md
salt-form/SKILL.md
salt-pattern/SKILL.md
salt-figma/SKILL.md
.mcp.json # Shareable MCP server config
package.json
tsconfig.jsonReferences
Salt Design System — official site
Salt DS GitHub — source code
Model Context Protocol — MCP specification
Agent Skills — open standard for portable agent skills
Available Tools
6 toolsget-component-exampleA
Get Storybook example code for a Salt component. Returns the story source showing how to use the component.
Inputs: component (required).
get-component-propsB
Get the props/API definition for a specific Salt component. Returns the TypeScript interface with JSDoc comments.
Inputs: component (required).
get-salt-docsA
Get Salt Design System documentation including usage guidelines, best practices, accessibility rules, and patterns. Use this to answer questions about how and when to use Salt components, design foundations (density, spacing, color, typography), and UI patterns (forms, navigation, search).
Inputs: topic (required), section.
helloA
Say hello — use this to test that the Salt MCP server is working
Inputs: name.
list-componentsA
List all available Salt Design System components. Returns component names from both core (stable) and lab (experimental) packages.
Inputs: package.
search-componentsC
Search Salt components by keyword. Searches component names and directory names.
Inputs: query (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Every tool has a clearly distinct purpose with no ambiguity: get-component-example retrieves example code, get-component-props provides API definitions, get-salt-docs returns documentation, hello is a test tool, list-components enumerates components, and search-components performs keyword searches. There is no overlap in functionality that could cause misselection.
The naming is mostly consistent with a verb_noun pattern (e.g., get-component-example, list-components, search-components), but the 'hello' tool deviates as a single-word, non-descriptive name. This minor inconsistency slightly reduces predictability, though the other tools follow a clear convention.
With 6 tools, the count is well-scoped for a Salt Design System server, covering key operations like listing, searching, retrieving examples, props, and documentation, plus a test tool. Each tool earns its place without being excessive or insufficient for the domain.
The tool surface is largely complete for accessing Salt Design System resources, covering listing, searching, and retrieving examples, props, and documentation. A minor gap is the lack of tools for interactive operations like modifying or testing components, but core informational workflows are well-covered without dead ends.
Maintenance
Related MCP Connectors
Live React design-system APIs, patterns, and code validation so AI agents build real UI, not slop.
React components and design rules your coding agent installs and follows.
Design systems your AI agent builds with and you reshape, plus standalone React components.
Search, read and install agent-ready React components, screens and blocks for AI products.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceProvides AI assistants with access to AegisX UI components, CRUD generator commands, development patterns, and API contract discovery tools. It enables developers to browse component documentation, build generation commands, and test authenticated API endpoints through the Model Context Protocol.41 npmMIT
- AlicenseCqualityDmaintenanceProvides AI agents with visibility into React applications by exposing tools to inspect component state, props, and performance metrics. It enables debugging and state analysis for both web and React Native applications through the Model Context Protocol.455 npm1MIT
- AlicenseAqualityCmaintenanceEnables AI agents to access and utilize GovBR Design System documentation, including component details, accessibility guidance, and search functionality via Model Context Protocol.311 npmMIT
- AlicenseAqualityBmaintenanceIt lets AI coding agents look up design tokens, component specifications, and prohibition rules on demand, then validate generated HTML or JSX with the same lint logic used by CI and editor hooks so violations are caught and corrected immediately. It also exposes the design constitution and rule sets as resources for reference during generation.6272 npm202MIT