How do I use genart-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@genart-mcp Create a p5.js sketch with rotating squares" 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.

genart-mcp

by genart-dev

Overview Schema Source Related Servers Discussions Admin

TypeScript

Hybrid

@genart-dev/mcp-server

Model Context Protocol server for genart.dev — 33 tools, 4 resources, and 3 prompts for creating and manipulating generative art with AI agents.

Works with any MCP client: Claude Code, Claude Desktop, Codex CLI, Cursor, and more.

Install

npm install -g @genart-dev/mcp-server

For screenshot/export capture, also install Puppeteer:

npm install -g puppeteer

Related MCP server: Processing MCP Server

Quick Start

Claude Code

claude mcp add genart-mcp -- genart-mcp

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "genart": {
      "command": "genart-mcp"
    }
  }
}

Codex CLI

Add to .codex/config.toml:

[mcp_servers.genart]
command = "genart-mcp"

Then ask your AI agent to create generative art:

"Create a workspace with a p5.js sketch that draws a grid of rotating squares using the golden ratio"

Tools (33)

Workspace (5)

Tool	Description
`create_workspace`	Create a new `.genart-workspace` with optional initial sketches
`open_workspace`	Open an existing `.genart-workspace` and load all sketches
`add_sketch_to_workspace`	Add an existing `.genart` file to the active workspace
`remove_sketch_from_workspace`	Remove a sketch from workspace (optionally delete file)
`list_workspace_sketches`	List all sketches with metadata summaries

Sketch Lifecycle (7)

Tool	Description
`create_sketch`	Create a new `.genart` sketch — supports all 5 renderers
`open_sketch`	Open a sketch by ID and set selection
`update_sketch`	Update metadata, parameters, colors, canvas
`update_algorithm`	Replace algorithm source code with optional validation
`save_sketch`	Persist in-memory state to disk
`fork_sketch`	Create a variant with new ID and optional modifications
`delete_sketch`	Delete sketch file and remove from workspace

Selection & Context (4)

Tool	Description
`get_selection`	Full context for selected sketch(es) — algorithm, params, colors, philosophy
`select_sketch`	Set canvas selection to one or more sketches
`get_editor_state`	Full snapshot of workspace, sketches, and selection
`set_working_directory`	Set base directory for sandboxed file operations

Parameters (5)

Tool	Description
`set_parameters`	Update runtime parameter values
`set_colors`	Update runtime color palette values
`set_seed`	Set random seed (or generate random)
`set_canvas_size`	Change dimensions via preset or explicit W/H
`randomize_parameters`	Generate random values for all/specific parameters

Arrangement (3)

Tool	Description
`arrange_sketches`	Move sketches to explicit canvas positions
`auto_arrange`	Auto-layout with grid, row, column, or masonry
`group_sketches`	Create/update named groups of sketches

Gallery (2)

Tool	Description
`list_sketches`	Scan a directory for `.genart` files with metadata
`search_sketches`	Search loaded sketches by title, renderer, params, skills

Merge (1)

Tool	Description
`merge_sketches`	Combine parameters, colors, and philosophies from 2+ sketches

Capture (3)

Tool	Description
`capture_screenshot`	Headless capture of a sketch — returns metadata + inline JPEG for AI viewing
`capture_batch`	Capture multiple sketches in parallel
`snapshot_layout`	Structural summary of workspace layout for spatial reasoning

Export (1)

Tool	Description
`export_sketch`	Export as standalone HTML, PNG, SVG, raw algorithm, or ZIP bundle

Knowledge (3)

Tool	Description
`list_skills`	List available design knowledge skills by category
`load_skill`	Load a skill with full theory, principles, and examples
`get_guidelines`	Design guidelines for composition, color, parameters, animation, performance

Resources (4)

URI	Description
`genart://skills`	Available design knowledge skills
`genart://presets/canvas`	Canvas dimension presets (18 built-in)
`genart://gallery`	Loaded sketches with metadata summaries
`genart://renderers`	Available renderer types and metadata

Prompts (3)

Prompt	Description
`create-generative-art`	Guided workflow: concept → sketch → algorithm → capture → iterate
`explore-variations`	Fork and explore parameter/seed space across multiple variants
`apply-design-theory`	Apply Gestalt, color theory, composition, rhythm, or contrast principles

Supported Renderers

Type	Runtime	Algorithm
`p5`	p5.js	`function sketch(p, state) { ... }`
`three`	Three.js	`function sketch(THREE, state, container) { ... }`
`glsl`	WebGL2	Fragment shader source
`canvas2d`	Native	`function sketch(ctx, state) { ... }`
`svg`	Native	`function sketch(state) { ... }`

Library API

For programmatic use (e.g., building a custom MCP host):

import { createServer, EditorState } from "@genart-dev/mcp-server/lib";

const state = new EditorState();
const server = createServer(state);

// Connect to any MCP transport
// ...

Exports from `@genart-dev/mcp-server/lib`

Export	Description
`createServer(state)`	Create a configured `McpServer` instance
`EditorState`	Server-scoped mutable state (workspace, sketches, selection)
`LoadedSketch`	Type — sketch definition + file path + dirty flag
`EditorMutationType`	Type — mutation event names (`sketch:created`, `workspace:loaded`, etc.)
`EditorMutationEvent`	Type — mutation event payload
`EditorStateSnapshot`	Type — serializable snapshot of all state

EditorState

const state = new EditorState();

// Load from disk
await state.loadWorkspace("/path/to/project.genart-workspace");

// Access loaded sketches
state.sketches;               // Map<string, LoadedSketch>
state.selection;              // Set<string>
state.workspace;              // WorkspaceDefinition | null

// Sandbox file operations (for hosted environments)
state.basePath = "/safe/dir";
state.remoteMode = true;      // Return file content instead of writing to disk

// Listen for mutations
state.on("mutation", (event) => {
  console.log(event.type);    // "sketch:created", "workspace:loaded", etc.
});

// Serializable snapshot
const snapshot = state.getSnapshot();

Modes

stdio (default)

Standard MCP transport for CLI agents:

genart-mcp

Sidecar

Stdio transport + IPC mutation bridge for Electron app integration:

genart-mcp --mode sidecar

Mutations are forwarded to the parent process via Node IPC, enabling real-time UI updates when AI agents modify sketches.

Agent Attribution

Most mutation tools accept optional agent and model parameters for provenance tracking:

{
  "agent": "claude-code",
  "model": "claude-opus-4-6"
}

Stored in sketch metadata to track which AI agent created or modified each sketch.

Package	Purpose
`@genart-dev/format`	File format types, parsers, presets
`@genart-dev/core`	Renderer adapters, skill registry (dependency)

Support

Questions, bugs, or feedback — support@genart.dev or open an issue.

License

MIT

This server cannot be deployed

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

mcp-flux-proOAuth
io.github.AceDataCloud
MCP server for Flux AI image generation
Image & Video Processing Multimedia Processing
23
humanMCP — kapoost B
io.github.kapoost
Personal MCP server for humans who create. Proof of authorship, license control.
Art & Culture Blockchain
4221
neverinfamous-memory-journal-mcp
ai.smithery
A MCP server built for developers enabling Git based project management with project and personal…
Version Control Developer Tools Project Management
320
mcp-producerOAuth
io.github.AceDataCloud
MCP server for Producer/Riffusion AI music generation
Audio Processing AI & Machine Learning
22

Related MCP Servers

ShaderToy-MCP
Multimedia Processing Code Execution Developer Tools
wilsonchenghy
A
license
Not graded
quality
C
maintenance
MCP Server for ShaderToy, a site where people share GLSL shader. This MCP server allows LLMs to make complex shader they aren't normally capable of.
Updated a year ago (2025-05-07 03:43 UTC)
50
MIT
Processing MCP Server
Art & Culture Developer Tools Code Execution
twelve2five
A
license
Not graded
quality
D
maintenance
An MCP server that enables AI assistants to create and run Processing sketches directly through natural language commands.
Updated a year ago (2025-06-03 18:52 UTC)
4
MIT
nakkas
Design Tools Image & Video Processing Developer Tools
arikusi
A
license
A
quality
A
maintenance
MCP server that turns AI into an SVG artist. One rendering engine with a rich JSON schema, AI controls all design parameters. Renders animated SVGs with CSS @keyframes and SMIL animations. Supports 16+ element types, parametric curves, pattern groups, gradient/filter/clip/mask definitions, and PNG preview. No external dependencies, runs locally via npx.
Updated 2 months ago (2026-07-14 12:30 UTC)
3
187 npm
22
MIT
theo-van-gogh-mcp
Art & Culture Social Media Marketing
johnfire
F
license
Not graded
quality
D
maintenance
MCP server that lets AI assistants manage an art catalogue — find paintings, post to social media, upload to galleries, schedule posts, and update metadata.
Updated 7 months ago (2026-02-27 17:55 UTC)
-