Skip to main content
Glama

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 build

Register 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 directory

  • Cursor: 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

hello

Test that the server is running

list-components

List all Salt components (core, lab, or both)

get-component-props

Get the TypeScript props interface for a component

get-component-example

Get Storybook example code for a component

search-components

Search components by keyword

get-salt-docs

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

salt-app

Scaffold a new React app with Salt DS (SaltProvider, theme, Vite)

salt-page

Build page layouts using Salt layout components

salt-form

Build forms following Salt's form pattern

salt-pattern

Build any of 20+ Salt UI patterns (search, navigation, wizard, etc.)

salt-figma

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 pull

No 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 mode

Project 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.json

References

Available Tools

6 tools
get-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

    A3.7/5.0

    Scored across 6 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides 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 npm
      MIT
    • A
      license
      C
      quality
      D
      maintenance
      Provides 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.
      45
      5 npm
      1
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to access and utilize GovBR Design System documentation, including component details, accessibility guidance, and search functionality via Model Context Protocol.
      3
      11 npm
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      It 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.
      6
      272 npm
      202
      MIT