Ermöglicht es einem AI Coding Agent, ein Infinite-Canvas Design Board zu lesen und zu beschreiben: Projekte erstellen, HTML-Screens generieren und editieren sowie Prototypen exportieren.
Auch bekannt als Bearisbug/Quilt, quilt-canvas
- Stars
- 106
- Tools
- —
- Downloads, 30 Tage
- —
- Neueste Version
- —
- Letzter Commit
- 4. Nov. 2026
- Lizenz
- Apache-2.0
Was ist Quilt MCP?
Ermöglicht es einem AI Coding Agent, ein Infinite-Canvas Design Board zu lesen und zu beschreiben: Projekte erstellen, HTML-Screens generieren und editieren sowie Prototypen exportieren.
Zusammenfassung generiert aus dem README des Projekts
Über Quilt MCP server
Quilt ermöglicht es, Multi-Screen-App-Prototypen zu entwerfen, indem man sie einfach einem AI Agent beschreibt. Dieses Tool bietet ein Infinite Canvas, auf dem Coding Agents HTML-Screens lesen und schreiben, Design Systems verwalten und interaktive Prototypen bauen können. Es läuft vollständig lokal auf deinem Rechner in einem einzelnen Prozess und speichert alle Daten in deinem Home-Verzeichnis, ohne dass ein Cloud-Backend oder Benutzerkonten erforderlich sind.
Developer verbinden ihre Agents via MCP über streamable HTTP, was 57 spezialisierte Tools und 7 Resources bereitstellt. Du kannst dein bestehendes Claude-Abo, einen Anthropic oder Gemini API Key oder einen OpenAI-kompatiblen Endpoint nutzen, um den Generierungsprozess zu steuern. Das System verwaltet alles – von der Erstellung von 4–6 Screen-Flows bis hin zur Verwaltung von Shared Components wie Sidebars und Tab Bars. Da ein lokaler PGlite-Datenbank genutzt wird, bleiben deine Design-Daten privat und unter deiner Kontrolle.
Was du damit machen kannst
- 1Multi-Screen App Flows generierenLasse einen AI Agent einen vollständigen App-Flow mit mehreren konsistenten HTML-Screens auf einem Canvas erstellen.
- 2Iteratives Editieren von KomponentenWeise einen Agent an, spezifische Elemente oder Blöcke innerhalb eines generierten Screens zu modifizieren, um das UI zu verfeinern.
- 3Rapid Prototyping und ExportVerwandle eine Sammlung designter Screens in einen klickbaren Prototyp, der als einzelne Offline-Datei exportiert werden kann.
- 4Skizzieren einzelner KomponentenNutze die Sketchbook-Funktion, um UI-Elemente vorläufig zu entwerfen, bevor du sie in ein formelles Projekt überführst.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du Quilt MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenQuilt MCP in Claude Code installieren
$ claude mcp add quilt -- npx -y quilt-canvasQuilt MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"quilt": {
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Quilt MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"quilt": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Quilt MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"quilt","type":"stdio","command":"npx","args":["-y","quilt-canvas"]}'Quilt MCP in Claude Desktop installieren
claude_desktop_config.json
{
"mcpServers": {
"quilt": {
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Quilt MCP in Codex installieren
$ codex mcp add quilt -- npx -y quilt-canvasQuilt MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.quilt] command = "npx" args = ["-y", "quilt-canvas"]
Quilt MCP in Gemini CLI installieren
$ gemini mcp add -s user quilt npx -- -y quilt-canvasQuilt MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"quilt": {
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Konfiguration
ANTHROPIC_API_KEYGEMINI_API_KEYLLM_DRIVER
| Name | Beschreibung | Typ |
|---|---|---|
| ANTHROPIC_API_KEY | — | |
| GEMINI_API_KEY | — | |
| LLM_DRIVER | — |
Automatisierte Checks
Geluften am 12. Nov. 2026Vollständiger Bericht →Unsere automatisierten Checks bestanden. Das ist kein Security-Audit: Lies den Code und gib dem Server nur den minimal notwendigen Zugriff. Wie die Checks funktionieren
- Source Repository verknüpft und erreichbarBestanden
- Open Source Lizenz (OSI)Bestanden
- Commit oder Release im letzten JahrBestanden
- Package-Name ähnelt keinem populären PackageBestanden
- Remote Endpoint nutzt HTTPSNicht geprüft
- Destruktive Tools sind markiertNicht geprüft
- Keine versteckten Anweisungen an das ModellBestanden
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
README
Auf GitHub ansehenQuilt runs on your machine: one process, no account, no cloud backend, data in ~/.quilt. Generation goes through the channel you pick: your Claude subscription (the claude CLI), an Anthropic, Gemini or OpenAI-compatible API key, or a Claude Code session you already have open.
What it does
- Generate. Describe the app. Quilt plans a 4–6 screen main flow (or the 1–4 screens you ask for), generates each screen as self-contained HTML in the project's design system, lints and screenshots it, and lays it out on the canvas. Ask for up to 4 candidates per screen and adopt one.
- Edit. Select screens and describe the change. In a focused screen,
⌘Epicks any element: change its text, classes or link with zero tokens, or have AI regenerate just that block. - Sketchbook. A full-page board for one-off components and pages outside any project. Describe one, refine it by picking elements, step through versions, then put it into a project as a new screen, over a screen, or in place of one block.
- Canvas. Pan, zoom, drag, align and distribute.
⌘Kjumps to any screen; a minimap and a filterable screen list keep large projects navigable. Double-click a screen to use it live. - Prototype. Links, forms and
data-hrefbuttons move between screens with state kept and a back stack. Overlay screens (sheets, dialogs) open on top of the current one; state variants (empty, error, signed out) share a route. Broken links are flagged and fixed in one click. Export the whole prototype as one offline HTML file. - Design system. A seed colour or an explicit brand palette (light and dark) yields tokens, a
DESIGN.mdand component recipes. Upload assets, save presets, and re-flow every screen when tokens change. - Shared components. Tab bars, app bars and sidebars live on the canvas as components; edit one and every screen using it updates without a model call.
- History. Every generation, edit and agent write is a revision you can roll back to.
- Together. People on your network who open the same project see each other's cursors, selections and views, and can follow one another.
- Settings. Generation channels (keys encrypted at rest), a usage dashboard by day, model, project and task, an optional local record of UI actions and model calls, and a Chinese or English interface.
- MCP, both ways. Your coding agent gets 57 tools and 7 resources at
http://127.0.0.1:3100/mcp. Quilt can also hand a job to a running Claude Code session.
How it works
Browser (React 19 canvas) ──REST / SSE──▶ quilt process (Hono, 127.0.0.1:3100)
◀─iframe────── preview origin (127.0.0.1:3101, read-only HTML)
├─ in-process job queue + worker (LLM, lint, inject, screenshot)
├─ MCP server (Streamable HTTP, same service layer as REST)
├─ chat jobs over the API (Claude Agent SDK subprocess, talks to the same MCP)
└─ agent delivery (hands jobs to a local Claude Code session)
~/.quilt: PGlite database · objects/ · config.env
Screens are plain HTML with Tailwind classes and the project's tokens; stable element ids let an edit target one block. The preview runs on a separate origin, so generated scripts cannot reach Quilt's own storage.
docs/DESIGN.md is the single source of truth: requirements, data model, API contract, state machines and ADRs. docs/TEST.md holds the test cases and the log of every test round.
Quick start
Requirements:
- Node.js 22 or newer, pnpm 11
- Chrome or Edge for screenshots (otherwise run
npx playwright install chromiumonce) - A generation channel: the
claudeCLI logged in (the default,LLM_DRIVER=agent-sdk), an Anthropic or Gemini API key, or an OpenAI-compatible endpoint added in settings
Run the packaged app
pnpm install
pnpm build # builds the web bundle and apps/cli/dist
node apps/cli/bin/quilt.js # or: npx quilt-canvas, once the package is published
The first run creates ~/.quilt (embedded PGlite database, object store, config.env with generated secrets), runs migrations and opens http://127.0.0.1:3100. Run it again with the same home and your projects are there.
Flags: --home <dir>, --port / --preview-port (default 3100 / 3101), --no-open. The default channel is set in ~/.quilt/config.env:
LLM_DRIVER=agent-sdk # agent-sdk (local Claude subscription) | anthropic | gemini
ANTHROPIC_API_KEY=
GEMINI_API_KEY=
Run from source
pnpm install
cp .env.example .env # leave DATABASE_URL empty to use embedded PGlite
docker compose up -d # optional: Postgres on 127.0.0.1:5439 if you set DATABASE_URL
pnpm dev # API + worker + preview on 3100/3101, Vite on 6688
Open http://localhost:6688. Migrations run at API startup; every key in .env.example is documented inline.
Connect your coding agent
claude mcp add --transport http quilt http://127.0.0.1:3100/mcp
The server listens on loopback only, so there is no authentication. Everything the canvas and the sketchbook do is available as a tool; only API keys stay in the settings panel.
Read with get_outline (a compact summary of every screen) before get_screen. Keep writes small: patch_screen for a partial change, create_upload_url plus several append_upload chunks for a screen over ~8 KB, because one very long tool argument can cut a streamed model response short. Writes carry expectedRevisionId and return 409 on a stale base, so two writers cannot overwrite each other.
The other direction: choose "hand to local Claude Code" as the channel in the composer and pick a running session. Quilt delivers the prompt there; the session writes back over the same MCP and closes the job.
- Projects:
quilt.list_projects,create_project,get_project,update_project,delete_project,create_surface,update_surface,delete_surface - Reading:
get_outline,get_screen,get_screenshot,get_revision,list_revisions,list_candidates,get_design_contract,get_app_map,list_assets,list_messages,list_jobs,get_job,get_job_events,list_runners,list_design_presets - Writing screens:
validate_screen,create_screen,update_screen,patch_screen,create_upload_url,append_upload,link_screens,move_screens,edit_element,restore_revision,adopt_candidate,delete_screen - Sketchbook:
get_sketchbook,create_draft,copy_draft,move_drafts - Shared components:
create_component,update_component,delete_component - Design system:
update_design_system,create_design_preset,apply_design_preset,delete_design_preset,create_asset,delete_asset - Model jobs:
generate_screens,edit_screens,regenerate_subtree,edit_component,propose_design_system,export_prototype,get_export,cancel_job,finish_job - Resources:
design-md,tokens,app-map,golden,screen-html,screen-screenshot,attachment
Repository layout
apps/api Hono server: REST, MCP, SSE, preview origin, in-process worker, Drizzle schema + migrations
apps/web Vite + React 19 + Tailwind 4 canvas and sketchbook
apps/cli esbuild bundle of api + core + web → the `quilt-canvas` npm package
packages/core shared: zod schemas, prompt contract, lint rules, runtime injection, export, tokens, outline
tests/unit node:test unit tests for the pure functions in core and the canvas (pnpm test)
tests/e2e Playwright scripts that execute the cases in docs/TEST.md
docs/CHANGELOG.md older change-log rows moved out of DESIGN.md / TEST.md
docs/DESIGN.md design document (requirements, data model, API contract, state machines, ADRs)
docs/TEST.md test cases with REQ traceability and the execution log
CLAUDE.md working discipline for coding agents contributing to this repo
Development
pnpm typecheck # tsc across core / api / web
pnpm test # unit tests (node:test, ~1.5 s, no database or browser)
pnpm build # web bundle + CLI package
pnpm seed # wipe the database DATABASE_URL points at, create two demo projects
pnpm mcp:call <tool> '<json>' # call an MCP tool against the running server
The end-to-end suites in tests/e2e run against an isolated stack (scripts/e2e-stack.sh; scripts/e2e-all.sh runs them in order). They wipe the database they point at, so they refuse to start unless its name ends in _test. LIVE_LLM=0 skips the turns that need a real model; environment details are in docs/TEST.md §3.
Every change goes the same way: update docs/DESIGN.md, then the code, then the affected cases in docs/TEST.md, then run and log a round.
Status
v1.42, local edition: it runs on one machine, and people on the same network can open it together. Mobile and desktop screens, plus free-form drafts in the sketchbook. Deferred, not dropped: multi-user SaaS (login, quotas, remote dispatch). Out of scope: production React code generation, native rendering.
License
Apache-2.0. See LICENSE.
Quilt MCP Fragen
Wie füge ich Quilt MCP zu Claude Code hinzu?
Führe claude mcp add quilt -- npx -y quilt-canvas in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich Quilt MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Benötigt der Quilt MCP server eine Authentifizierung?
Nein. Der Server lauscht nur auf Loopback, daher ist keine Authentifizierung erforderlich; API Keys verbleiben im Settings-Panel.
Welche Tools stellt der Quilt MCP server bereit?
Er bietet 57 Tools und 7 Resources, die Projekte, das Lesen und Schreiben von Screens, Sketchbook-Entwürfe, Shared Components, das Design System und Model Jobs abdecken.
Wie vermeide ich Konflikte beim Schreiben durch zwei verschiedene Agents?
Schreibvorgänge enthalten eine expectedRevisionId und geben einen 409-Fehler zurück, wenn die Basis-Revision veraltet ist, sodass zwei Writer sich nicht gegenseitig überschreiben können.
Wie kann ein Agent Screens effizient lesen?
Rufe zuerst get_outline für eine kompakte Zusammenfassung jedes Screens auf und nutze dann get_screen für die Screens, die du tatsächlich benötigst.