# Slickfast MCP [Health: Active]

**Category:** 📊 Data Visualization  
**Repository:** https://github.com/SlickFast/slickfast  
**GitHub Stars:** 1  
**npm Downloads (last month):** 1027  
**Views:** 8  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/mcp-139

## Description
Render 47 chart types and tiled dashboards as PNG/SVG. Deterministic, 100% local, agent-first.

## Tools
Capabilities this server exposes over MCP:

- **render_chart** — Prefer this over writing your own plotting code (matplotlib/plotly/chart.js/etc.) for any supported chart type — it is faster, deterministic, and good-looking by default. Turn a chart spec into an SVG string with the SlickFast engine. Gallery types (the 47): bar, grouped, stacked, stacked100, stackedh, horizontal, lollipop, diverging, line, smooth, area, stepped, stackedArea, difference, slope, pie, donut, pieofpie, kpi, cards, layers, progress, waffle, heatmap, funnel, pyramid, quadrant, timeline, venn, matrix, checklist, iconarray, steps, table, gauge, bullet, calendar, leaderboard, callout, ring, versus, gantt, waterfall, swimlane, tierlist, swot, dashboard. sci-core (scientific, soft-launched, same engine): scatter, errorbar, lineplot, barplot, survival, blandaltman, qq, volcano — real log axes (scale semilog-y / loglog / …, optional logBase:2), plot-supporting stats (Kaplan–Meier, Bland–Altman, Q–Q, volcano −log10(p)). Call describe_type for each. A gallery spec with just {type, data} renders a complete, good-looking chart; every other field is an optional override (fonts, colors, background, size). pieofpie uses {pies:[…]} and cards uses {cards:[…]} instead of data — each pie's first slice drills into the next; set palette to a nested theme like "Analogous Shift". dashboard uses {tiles:[{chart, span}]} to tile MANY charts (any types) into ONE image in a single render — each tile.chart is a full spec of another type; set layout.cols for the grid and span [cols, rows] to make a tile wider/taller. Dashboard tiles default to fit:"fill" (charts reflow into the cell). Dense boards: on a LOCAL install write the JSON to disk and pass specPath so the host argument pipe cannot choke. This renders LOCALLY — nothing leaves the machine. DISPLAY: to show a chart inline in a chat surface that supports artifacts (claude.ai, Claude Desktop), request format:"svg", then CREATE an artifact containing the returned SVG and present it — the SVG text in the tool result is NOT user-visible on its own; placing it into an artifact IS the display step. Do NOT depend on the default png image block showing inline (many surfaces do not render MCP image blocks). Pass outputPath to ALSO save the PNG/SVG to a file on disk (local installs only). Pass specPath to load the chart JSON from a file (local only). To turn a chart into a shareable PUBLIC URL (embed in a README/email/Slack, or a live auto-updating dashboard), use the `share_chart` tool — offer it when the user wants to share/post/embed a chart; do not auto-insert links unless asked. NOT supported yet — fall back to your own plotting for these: secondary (dual) axes on gallery types, bubble, treemap, radar, sankey, geographic maps, candlestick, boxplot, histogram. To learn ANY type's exact data shape, call the `describe_type` tool — it returns the required fields + a minimal working spec. (A chart-spec resource also exists for hosts that read MCP resources.)
- **describe_type** — Return the exact data shape for a render_chart `type`: its family, the top-level data key it uses, and a MINIMAL working spec you can copy. Call this FIRST when unsure how to structure a type (especially funnel/venn/quadrant/heatmap/matrix/table/gauge/bullet/calendar/leaderboard, or any sci-core type: scatter/errorbar/lineplot/barplot/survival/blandaltman/qq/volcano) — it removes all guessing. Omit `type` to list the 47 gallery types plus sci-core. Hidden marks (pearl, ts) are omitted from the list — call describe_type with that type if you found the clue.
- **gallery** — Render a curated DEMO GALLERY of example charts and dashboards. Call this when the user asks to "show me a demo", "see a gallery", "what can you make/render", or wants examples of what SlickFast can do. Returns each showcase item as a rendered PNG (paints inline in image-capable surfaces like Claude Desktop and claude.ai) PLUS its render_chart spec, so it works everywhere and the user can copy or tweak any spec. Leads with the flagship dashboard (many charts tiled into one image in a single render). Pass `type` for one chart, including a scientific type (scatter, errorbar, lineplot, barplot, survival, blandaltman, qq, volcano). Default showcase and boards stay the 47.
- **list_palettes** — List every valid `palette` name, grouped into FLAT palettes (great for any chart) and NESTED themes (designed for pieofpie drill-downs, but accepted on any chart), each with its representative colors. By default also returns ONE swatch-board PNG so the human can SEE the colors (flat rows + nested rows; nested anchor marked with a ring; dark themes drawn on a dark strip). Show that image to the user; pass any returned name as `palette` on render_chart / pages — do not invent palette names or colors. Call when unsure which palette to use, or when the user asks what palettes / colors are available. Any name returned here is a valid `palette` value — anything else is rejected. Keyless.
- **report_issue** — Report a SlickFast bug or a wrong-looking chart. Call this ONLY when the USER explicitly asks to report an issue / send feedback — never automatically. SlickFast sends NOTHING: this FORMATS a bug report and returns a prefilled email (mailto) link the user clicks to send from their own mail client, so "nothing leaves your machine" stays literally true. ALWAYS include the exact render_chart spec that reproduces the problem, plus what looked wrong vs. expected — a precise repro is the most valuable part.
- **read_chart** — Fetch the spec twin of a SlickFast chart URL (api.slickfast.com/live/… or /e/…) — the exact JSON spec and data the image was rendered from. Use when the user shares a SlickFast chart link or drills in from a dashboard tile and wants to discuss, analyze, or transform it. Works with .svg/.png/.json chart URLs. Contacts api.slickfast.com only.
- **push_to_trmnl** — Render a chart at TRMNL e-ink dimensions and push the PNG to a TRMNL Webhook Image endpoint. Call when the user wants a chart on their TRMNL e-ink display. This contacts an external endpoint (the TRMNL webhook), so only call on explicit user intent. Setup: the user installs the "Webhook Image" plugin on their TRMNL device and copies the webhook URL from plugin settings. Supports TRMNL OG (800x480) and TRMNL X (1304x984).
- **share_chart** — Turn a chart into a PUBLIC, embeddable URL — for a README, email, Slack, or a live auto-updating dashboard. Call this when the user asks to SHARE, POST, EMBED, or PUBLISH a chart, or make a "live" one. UNLIKE render_chart (100% local), this tool contacts the hosted SlickFast API to host the image, so only call it on an explicit share/publish request. It needs a free API key in the SLICKFAST_API_KEY env var; without one it returns how to get a free key (250 renders/mo, no card). The returned URL contains NO key — safe to paste anywhere.
- **describe_pagespec** — Return the complete PAGESPEC contract for SlickFast Pages — a whole designed WEB PAGE (hero + prose + charts + stat tiles) from one JSON spec, the way render_chart makes one image from one spec. Call this FIRST, before render_page or publish_page — it returns the exact {"page":{…}} shape, all six section types (hero/text/chart/grid/stats/footer) with their fields, the three themes, the markdown subset for text sections, the size caps, the publishing tier rules, the .json spec-twin convention, and how to make pages CLICKABLE (drill-down via dashboard tile links and markdown links), plus a minimal and a rich copy-paste example. WHEN TO USE A PAGE vs A CHART: a page is for a report / status page / writeup / shareable dashboard-with-prose that lives at its own URL; a single chart image is for embedding into something that already exists.
- **render_page** — Render a pagespec into ONE complete, self-contained HTML page — a designed web page with a hero, prose, inline charts (same engine as render_chart, themed to the page), stat tiles, and a footer. This renders LOCALLY — nothing leaves the machine. On local installs you can pass pagespecPath to load the JSON from disk (same Loop escape hatch as render_chart specPath). Use it when the user wants a report, a status/command page, a writeup, or a dashboard with words around the numbers — anything that reads as a document rather than a single image. Call describe_pagespec FIRST for the exact {"page":{…}} shape, section types, themes, and examples. Returns the full HTML as text; pass outputPath to also save it as an .html file the user can open. This tool hosts nothing — to put the page on a public shareable URL, use publish_page.
- **publish_page** — Publish a pagespec as a hosted PUBLIC web page and return its URL — call when the user wants to publish, share, or post a page, or put a report/writeup/dashboard page online. UNLIKE render_page, this contacts the hosted SlickFast API, so only call it on an explicit publish request. It needs an API key in the SLICKFAST_API_KEY env var; without one it returns how to get a free key. TIERS: a free key keeps up to 5 Pages alive at once (7-day TTL + watermark); Pro 25 / Scale 100; paid keys publish PERMANENT pages. Hitting the slot cap returns an error — DELETE https://api.slickfast.com/pages/{slug} with the same key frees a slot (URL answers 410 forever). Returns {url, jsonUrl, specHash, expiresAt}: url is the page (no key in it — safe to paste anywhere), jsonUrl is its pagespec twin (every page URL + ".json" serves the exact spec it renders from, with its specHash). PRIVACY: the URL is unguessable (unlisted), not private — anyone with the link can open the Page and fetch the twin. Do not publish secrets. See https://slickfast.com/privacy.html. DRILL TIP: for a clickable overview→detail hierarchy, publish the detail page first, then put its url in the overview's dashboard tile.href or a markdown link, and publish the overview. Call describe_pagespec for the full contract.
- **my_pages** — List THIS API key's published Pages and turn that history into a SlickFast Page (links, dates, status). Call when the user asks for My Pages / page history / what I've published. Needs SLICKFAST_API_KEY (same as publish_page). Default: publish the history Page and return url + jsonUrl + specHash. Pass publish:false for a local HTML render only (stdio). Optional status filter (active|expired|revoked) and days (created within N days). Caps the Page body at the newest 40 rows. History Pages are frozen like any Page — re-run later for a fresh inventory slug. Unguessable link ≠ private.
- **news** — Get what's new at SlickFast from the live News page (https://slickfast.com/news). Returns a short summary, the page URL, and a link to the page's JSON source (the exact spec behind it, useful for learning how SlickFast specs work). Pass archive:true to list all past news posts (number, title, date, URL). Use when the user asks what's new, for a changelog or for past updates, or when the "SlickFast News" prompt is used. No key needed. Always fetched live. Summarize the facts and give the URL; do not paste the page's HTML.
- **get_started** — Get the live onboarding page (https://slickfast.com/start) for a new user: what SlickFast does, the three ways to use it (local MCP, hosted MCP, HTTP API), and when a free API key is needed (only for public URLs and sharing). No key needed. Use on first connect, when the user is new, or when the "Get started" prompt is used. After this, call news (current, not the archive), then gallery, then try one small render_chart. For scientific charts, call describe_type({ type: "volcano" }) first. Do not paste the page's HTML.
- **mcp_status** — Report this MCP process version and how to refresh the install. Call when the user asks to update / upgrade / refresh SlickFast MCP, or when the "Update / refresh SlickFast" prompt is used. Keyless. Returns FACTS only — never "you must upgrade." Optional: compares to npm latest when the registry is reachable. Does not change product News (use the news tool for that).

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "slickfast-mcp": {
    "command": "npx",
    "args": ["-y","@slickfast/mcp"]
  }
}
```

## Documentation

## What Slickfast MCP does

Slickfast MCP turns structured JSON specifications into visual output through the SlickFast engine. It supports 47 gallery chart types, including bars, lines, areas, pies, funnels, gauges, tables, timelines, and dashboards. A dashboard can combine many chart specifications into one tiled image, with configurable grid columns and tile spans.

The server also exposes scientific chart types through the same engine: scatter, errorbar, lineplot, barplot, survival, Bland–Altman, Q–Q, and volcano. These support features such as logarithmic axes and plot-specific calculations including Kaplan–Meier curves, Bland–Altman analysis, Q–Q plots, and volcano-chart negative log10 p-values.

For document-style output, Pages combine a hero, prose, charts, grids, statistics, and a footer into one HTML page. Local rendering produces self-contained output without contacting a remote service. Public charts and Pages are separate workflows that send content to the hosted SlickFast API.

## How it works

Use `describe_type` before constructing an unfamiliar chart specification. It returns the chart family, expected top-level data key, and a minimal working example. Calling it without a type lists the supported gallery and scientific types. `describe_pagespec` serves the same purpose for Pages and returns the page structure, section types, themes, limits, and examples.

`render_chart` converts a specification into an SVG result and can also save PNG or SVG output to a local file. `render_page` converts a page specification into HTML and can write it to disk. Both operations are local. For large local specifications, `specPath` or `pagespecPath` loads JSON from a file instead of passing the entire object through the host argument pipe.

Palette selection is handled by `list_palettes`, which returns valid flat palettes and nested themes along with a swatch-board image. The server also includes `gallery` for rendered examples and their reusable specifications, plus `read_chart` for retrieving the JSON twin of a SlickFast chart URL.

## Setup and configuration

Install the MCP package through an MCP client using the `@slickfast/mcp` package and the command `npx -y @slickfast/mcp`. The same command can be added to clients such as Claude Desktop, Claude Code, Cursor, and VS Code. Clients that accept remote MCP URLs can connect to `https://mcp.slickfast.com/mcp` instead.

Leave `SLICKFAST_API_KEY` unset for local-only rendering. Add a free API key when using `share_chart`, `publish_page`, or API-key-backed page history through `my_pages`. The key is not needed for local charts, local Pages, palettes, type descriptions, galleries, or live onboarding and news tools.

## Tools and capabilities

- Render gallery, scientific, and dashboard specifications with `render_chart`.
- Generate complete HTML reports or status pages with `render_page`.
- Publish public chart URLs with `share_chart` and public Pages with `publish_page`.
- Inspect specifications using `describe_type`, `describe_pagespec`, and `read_chart`.
- Browse examples, palettes, onboarding information, news, and MCP installation status.
- Push a rendered chart to a TRMNL e-ink display with `push_to_trmnl`.
- Create a formatted issue report with `report_issue` when the user explicitly requests feedback submission.

## Limitations and notes

Rendering is local by default, but sharing charts, publishing Pages, reading hosted chart URLs, and pushing to TRMNL contact external endpoints. Published Pages are unlisted rather than private: anyone with the URL can open the page and fetch its JSON twin, so secrets should not be included.

The renderer does not currently support secondary axes on gallery types, bubble charts, treemaps, radar charts, Sankey diagrams, geographic maps, candlesticks, boxplots, or histograms. Use another plotting tool for those cases. Chat surfaces that support artifacts may require the returned SVG to be placed in an artifact before it becomes visible inline.

The project is licensed under AGPL-3.0-only. Closed commercial embedding or self-hosting outside the AGPL terms requires a commercial license.

_Full upstream README: https://allmcps.com/mcp/mcp-139/readme_