Skip to main content
Glama
game-art-mcp

game-art-mcp

by Cuvara

game-art-mcp

KI-gesteuertes Pixel-Art-Stilsystem und MCP-Server für die Art Direction von 2D-RPG-Spielen.

Zweck

Dieses Repository ist die maßgebliche Quelle für die Art Direction des Projekts. Jeder KI-Agent kann in dieses Repository wechseln, den Projektkontext über MCP abfragen und genau verstehen, was „unser Kunststil“ bedeutet — ohne auf den Gesprächsverlauf angewiesen zu sein.

Related MCP server: Aseprite MCP Server

Architektur

game-art-mcp/
├── project.yaml              # Project config: which style is active
├── style/                    # Version-controlled style definitions
│   └── fantasy_pixel_v1/     # Style v1 (YAML rules + style bible)
├── registry/                 # Asset registry storage
│   ├── assets/               # One YAML file per registered asset
│   └── registry.yaml         # Auto-generated index of all assets
├── memory/                   # Art Memory storage (Phase 3)
│   ├── anchors/              # Style anchor YAML files
│   ├── references/           # Approved reference YAML files
│   ├── rejections/           # Rejection records
│   ├── decisions/            # Art decision records (ADR format)
│   ├── history.yaml          # Style version evolution log
│   └── memory.yaml           # Auto-generated memory index
├── src/
│   ├── style/                # Models, loader, validator
│   ├── assets/               # Asset registry (models + service)
│   │   ├── models/           # Zod schemas + TypeScript types
│   │   └── registry/         # AssetRegistry service (CRUD + query)
│   ├── memory/               # Art Memory (models, service, resolver)
│   │   ├── models/           # Zod schemas for anchors, references, rejections, decisions
│   │   ├── service/          # ArtMemoryService (CRUD + index)
│   │   └── resolver/         # ReferenceResolver (deterministic lookup)
│   ├── qa/                   # Art QA engine (Phase 4)
│   │   ├── models/           # QA types, report schema, rule interface
│   │   ├── rules/            # 13 deterministic rules (7 categories)
│   │   ├── runner/           # QARunner orchestrator
│   │   └── history/          # QA history persistence
│   ├── providers/            # Provider Adapters (Phase 5)
│   │   ├── models/           # ProviderAdapter interface, types, error codes
│   │   ├── adapters/         # Adapter implementations (mock-provider)
│   │   ├── registry/         # ProviderRegistry (adapter lookup + capabilities)
│   │   ├── gateway/          # ProviderGateway (dispatch + artifact storage)
│   │   └── artifacts/        # ArtifactStore (immutable provenance)
│   ├── production/           # Production Orchestrator (Phase 6)
│   │   ├── models/           # Types, state machine, error codes
│   │   ├── orchestrator/     # ProductionOrchestrator (coordinator)
│   │   └── store/            # ProductionStore (YAML manifest persistence)
│   ├── versioning/           # Versioning & Approval (Phase 7)
│   │   ├── models/           # Types, lifecycle states, error codes
│   │   └── services/         # VersioningService (approval, versioning, promotion, audit)
│   ├── context/              # ArtContextService
│   └── mcp/                  # MCP server + tools
│       └── tools/            # art-tools.ts, asset-tools.ts, memory-tools.ts, qa-tools.ts, provider-tools.ts, production-tools.ts, versioning-tools.ts
├── tests/                    # Unit + integration tests
└── docs/                     # Architecture, style system, phases

Schnellstart

npm install
npm run build
npm test

MCP-Server ausführen

npm start
# or with custom root:
ART_MCP_ROOT=/path/to/project npm start

Stil validieren

npm run validate

MCP-Werkzeuge

Stil-Werkzeuge (schreibgeschützt)

Werkzeug

Beschreibung

art.get_project_context

Vollständiger Art-Kontext (Projekt + Stil + alle Regeln)

art.get_style

Aktive Stildefinition

art.get_style_rules

Bestimmte Regelkategorie (pixel_language, Sprachen, usw.)

art.get_palette

Farbpalette mit semantischen Rollen

art.validate_style

Stilkonfiguration validieren

Asset-Werkzeuge (Lesen + Schreiben)

Werkzeug

Beschreibung

art.asset.get

Asset anhand der ID abrufen

art.asset.find

Assets suchen/filtern (Typ, Kategorie, Status, Tags)

art.asset.exists

Prüfen, ob eine Asset-ID registriert ist

art.asset.register

Neues Asset mit vollständiger Validierung registrieren

art.asset.update

Vorhandenes Asset aktualisieren (Teilupdate)

art.asset.deprecate

Asset als veraltet markieren

art.asset.archive

Asset archivieren

art.asset.rebuild_index

Registry-Index aus den Asset-Dateien neu aufbauen

Memory-Werkzeuge (Lesen + Schreiben)

Werkzeug

Beschreibung

art.memory.get_summary

Memory-Übersicht: Anker, Entscheidungen, Ablehnungen, Referenzanzahl

art.memory.explain_style

Vollständige Stil-Erklärung mit Regeln, Ankern, Entscheidungen und Vermeidungen

art.memory.resolve_references

Deterministische Referenzauflösung für einen bestimmten Kontext

art.memory.get_anchor

Stilanker anhand der ID abrufen

art.memory.find_anchors

Anker suchen (Kategorie, Status, Dimensionsfilter)

art.memory.add_anchor

Neuen Stilanker hinzufügen

art.memory.get_reference

Freigegebene Referenz anhand der ID abrufen

art.memory.find_references

Referenzen suchen (Rolle, Status, asset_id-Filter)

art.memory.add_reference

Neue freigegebene Referenz hinzufügen

art.memory.get_rejection

Ablehnungsdatensatz anhand der ID abrufen

art.memory.find_rejections

Ablehnungen suchen (Typ, Status, Grund-Filter)

art.memory.add_rejection

Neuen Ablehnungsdatensatz hinzufügen

art.memory.get_decision

Künstlerische Entscheidung anhand der ID abrufen

art.memory.find_decisions

Entscheidungen suchen (Statusfilter)

art.memory.add_decision

Neue künstlerische Entscheidung hinzufügen

art.memory.get_style_history

Vollständige Historie der Stil-Entwicklung abrufen

QA-Werkzeuge (schreibgeschützt)

Werkzeug

Beschreibung

art.qa.asset

QA-Prüfungen für ein einzelnes Asset ausführen (vollständiger Bericht)

art.qa.batchtext

QA-Prüfungen für mehrere Assets ausführen (Batch-Bericht)

art.qa.gate

QA-Gate-Prüfung — Ergebnis „bestanden/nicht bestanden“ für Freigabeworkflows

art.qa.list_rules

Alle verfügbaren QA-Regeln mit Definitionen auflisten

art.qa.rule

Vollständige Definition einer bestimmten QA-Regel anhand der ID abrufen

art.qa.explain_failure

Erklären, warum eine bestimmte Regel für ein Asset fehlgeschlagen ist

art.qa.history

QA-Ausführungsverlauf abrufen, optional nach Asset-ID gefiltert

Provider-Werkzeuge (Lesen + Schreiben)

Werkzeug

Beschreibung

art.provider.list

Alle registrierten Provider mit Metadaten auflisten

art.provider.get

Detaillierte Metadaten für einen bestimmten Provider abrufen

art.provider.capabilities

Provider-Fähigkeiten abrufen (Operationen, Formate, Limits)

art.provider.health

Health-Status des Providers prüfen

art.provider.execute

Kunstgenerierungsoperation erneut über einen Provider ausführen

art.provider.cancel

Laufende Provider-Operation abbrechen

art.provider.operation

Status einer Operation anhand der ID abrufen

art.provider.artifact

Artefakt-Details und Provenienz anhand der ID abrufen

Produktions-Werkzeuge (Lesen + Schreiben)

Werkzeug

Beschreibung

art.production.plan

Produktionsplan erstellen (Vorschau vor der Ausführung)

art.production.create

Produktions-Job erstellen (Plan + dauerhaft speichern, nicht starten)

art.production.start

Ausführung eines Produktions-Jobs starten

art.production.status

Aktuellen Jobstatus abrufen (Zusammenfassung)

art.production.inspect

Vollständige Jobdetails abrufen (Ereignisse, Versuche, Plan)

art.production.resume

Fehlgeschlagenen Job wiederaufnehmen

art.production.cancel

Laufenden Job abbrechen

art.production.attempts

Versuchsverlauf für einen Job abrufen

art.production.approve

Job genehmigen, der auf Freigabe wartet

art.production.list

Alle Produktions-Job-IDs auflisten

Versionsverwaltungs-Werkzeuge (Lesen + Schreiben)

Werkzeug

Beschreibung

art.asset.current

Kanonische (aktuelle) Version eines Assets abrufen

art.asset.inspect_version

Details einer bestimmten Asset-Version abrufen

art.asset.history

Vollständige Versionshistorie eines Assets abrufen

art.asset.compare

Zwei Versionen desselben Assets vergleichen

art.asset.provenance

Versionsprovenienz inklusive Freigabedatensatz abrufen

art.asset.approval.request

Freigabe für ein Kandidaten-Asset beantragen

art.asset.approval.inspect

Freigabedatensatz anhand der ID abrufen

art.asset.approve

Kandidaten-Asset genehmigen

art.asset.reject

Kandidaten-Asset ablehnen

art.asset.request_changes

Änderungen an einem Kandidaten-Asset anfordern

art.asset.promote

Genehmigtes Kandidaten-Asset zur kanonischen Version befördern

art.asset.rollback

Kanonische Version auf eine frühere Version zurücksetzen

art.asset.archive_version

Kanonisches Asset archivieren

Stil- und QA-Werkzeuge sind schreibgeschützt. Asset-, Memory-, Provider-, Produktions- und Versionierungs-Werkzeuge unterstützen Lese- und Schreibzugriffe.

Asset-Registry

Das Asset-Registry (Phase 2) erfasst jedes Art-Asset im Projekt mit strukturierten Metadaten. Assets werden als einzelne YAML-Dateien unter registry/assets/ gespeichert und in registry/registry.yaml indiziert.

Wichtige Merkmale:

  • Semantische IDs — durch Punkte getrennt, klein geschrieben (z. B. character.goblin.001)

  • Stil-Verknüpfung — jedes Asset referenziert eine Stil-ID + Version

  • Beziehungen — variant_of, derived_from, animation_of usw.

  • Statusverfolgung — draft, approved, rejected, deprecated, archived

  • Vollständige Validierung — Schema, Stilreferenz, Existenz der Quelldatei, Beziehungen

Siehe docs/ASSET-REGISTRY.md für die vollständige Dokumentation und docs/ASSET-METADATA.md für das Metadaten-Schema.

Art-Memory

Das Art-Memory-System (Phase 3) verleiht dem Repository dauerhaftes visuelles Wissen. Es speichert, was genehmigt wurde, was abgelehnt wurde und warum — sodass Agenten keine Gesprächshistorie benötigen, um die Art Direction des Projekts zu verstehen.

Wichtige Konzepte:

  • Stilanker — kanonische visuelle Beispiele, die den Stil definieren (siehe docs/STYLE-ANCHORS.md)

  • Genehmigte Referenzen — vertrauenswürdige Assets mit Rollen-Preferenzen. Ablehnungen — was NICHT passt, mit einem kontrollierten Vokabular an Gründen

  • Art-Entscheidungen — Datensätze im ADR-Format für visuelle Richtungsentscheidungen (siehe docs/ART-DECISIONS.md)

  • Referenz-Resolver — deterministische Referenzauflösung, die für jede Erstellungsaufgabe relevanten Kontext zurückgibt

Siehe docs/ART-MEMORY.md für die vollständige Dokumentation.

Art-QA

Das Art-QA-System (Phase 4) bietet deterministische, reproduzierbare Qualitätsprüfungen für Pixel-Art-Assets. Jeder Check ist regelbasiert mit Soll-/Ist-Werten und strukturierten Korrekturmaßnahmen — keine Bilderkennung, keine Embeddings, keine automatische Reparatur.

Wichtige Konzepte:

  • 13 Regeln in 7 Kategorien (Technik, Dimensionen, Palette, Alpha, Pixel, Stil, Memuery)

  • 3 Profile — „strict“ (schlägt bei Warnung fehl), „default“ (schlägt bei Fehler fehl), „lenient“ (schlägt nur bei kritischen Fehlern fehl)

  • Maschinenlesbare Berichte — JSON mit Ergebnissen pro Regel, Schweregrad und Korrekturmaßnahmen

  • Stil-Integration — liest Canvas-Größen, Farbgrenzen und Pixel-Regeln aus dem aktiven Stil

  • Memory-Integration — prüft total zurückgewiesene Richtungen und akzeptierte Art-Entscheidungen

  • QA-Gate — Ergebnis „bestanden/nicht bestandefor for CI und Freigabeworkflows

  • QA-Verlauf — persistentes Log aller Ausführungen pro Asset

Siehe docs/ART-QA.md für die vollständige Dokumentation.

Provider-Adapter

Das Provider-Adapter-System (Phase 5) fügt eine providerneutrale, anbieterunabhängige Schnittstelle zu externen Art-Generierungswerkzeugen hinzu. Anfragen laufen über ein Gateway, das Operationen validiert, an registrierte Adapter delegiert und generierte Artefakte mit unveränderlicher Provenienz speichert.

Wichtige Konzepte:

  • ProviderAdapter-Schnittstelle — Metadaten, Fähigkeiten, Health, Ausführung, Abbruch

  • Artefakte — Rohe Provider-Ausgabe mit unveränderlicher Provenienz (noch keine Assets)

  • Capabilities — Details pro Operation (Formate, maximale Auflösung)

  • Dry-run — Anfragen validieren, ohne Ausgabe zu generieren

  • Mock-Provider — eingebauter Testadapter mit Fehler-/Timeout-Modi

  • Keine automatische Auswahl — Agenten müssen einen Provider eExplicitly wählen

Siehe docs/PROVIDERS.md für die vollständige Dokumentation.

Produktions-Orchestrator

Der Produktions-Orchestrator (Phase 6) koordiniert den gesamten Lebenszyklus der Art-Asset-Generierung: request validation, Stil-/Referenz-/Provider-Auflösung, Ausführung, QA, Wiederholung und Freigabeprüfung.

Wichtige Konzepte:

  • Koordinator, keine Quelle der Wahrheit — delegiert an Stil, Qualitätssicherung, Anbieter und Registry

  • Zustandsmaschine — 9 Status mit validierten Übergängen (erstellt bis abgeschlossen/fehlgeschlagen/abgebrochen)

  • 11 Produktionsstufen — REQUEST_VALIDATION bis APPROVAL_GATE

  • Begrenzte Wiederholung — konfigurierbare max_attempts (Standard 3) mit Reparaturplänen bei QA-Fehlern

  • Genehmigungsgrenze — stoppt bei awaiting_approval, genehmigt niemals automatisch

  • Plan-Veraltung — erkennt Stilversionsabweichungen vor der Ausführung

  • YAML-Persistenz — ein manifest.yaml pro Auftrag in production/<job_id>/

  • Ereignishistorie — nur-anhängendes Protokoll aller Zustandsänderungen pro Auftrag

Siehe docs/PRODUCTION.md für die vollständige Dokumentation.

Versionierung & Genehmigung

Das Versionierungs- & Genehmigungssystem (Phase 7) fügt unveränderliche Asset-Versionierung, explizite Genehmigungsworkflows und eine vollständige Prüfpfad hinzu. Keine Version wird jemals gelöscht; kein Asset wird jemals automatisch genehmigt.

Wichtige Konzepte:

  • Asset-Lebenszyklus — 8 Zustände: Entwurf, ausstehende_Genehmigung, genehmigt, abgelehnt, Änderungen_angefordert, befördert, ersetzt, archiviert

  • Genehmigungsworkflow — anfordern, genehmigen, ablehnen, Änderungen_anfordern mit strukturiertem Feedback

  • Genehmigungsrichtlinie — konfigurierbar: requires_qa_pass, allow_agent_approval, requires_human

  • Unveränderliche Versionen — monotone Inkrementierung, Elternverfolgung, vollständige Herkunft pro Version

  • Kanonischer Zeiger — verfolgt, welche Version aktuell ist; wird bei Beförderung/Rollback aktualisiert

  • Beförderung — Vergleich-und-Tausch mit QA-Gate und Genehmigungs-Gate

  • Rollback — setzt den kanonischen Zeiger auf eine frühere Version zurück, löscht niemals die Historie

  • Prüfprotokoll — 9 Ereignistypen, nur-anhängend, unveränderlich

  • Akteursidentität — Mensch, Agent, System, Anbieter bei jedem Datensatz verfolgt

Siehe docs/VERSIONING.md für die vollständige Dokumentation.

Aktuelle Phase

Phase 7 — Versionierung & Genehmigung (abgeschlossen)

Siehe docs/PHASES.md für die vollständige Roadmap.

Stilsystem

Stile sind strukturierte YAML-Dateien, die maschinenlesbare künstlerische Richtung darstellen:

  • style.yaml — Identität, Leinwandgrößen, Skalierung

  • palette.yaml — Farben mit semantischen Rollen

  • pixel-rules.yaml — Pixel-Art-Einschränkungen

  • outline.yaml — Konturregeln

  • shape-language.yaml — visuelle Sprache

  • lighting.yaml — Lichtrichtung und -regeln

  • animation.yaml — Bildanzahl, FPS, Einschränkungen

Siehe docs/STYLE-SYSTEM.md für Details.

Available Tools

126 tools
art.aseprite.exportB

Export a canvas session to Aseprite format. Saves the canvas as PNG and generates the Aseprite CLI command to convert it. Commands are returned for external execution.

Inputs: session_id (required), output_name.

art.aseprite.layersA

Generate a Lua script and Aseprite command to set up standard layer structure. Writes the script to disk and returns the command to execute it.

Inputs: session_id (required), layers.

art.aseprite.spritesheetB

Generate a spritesheet export command for a canvas session. The canvas PNG is saved and a CLI command is returned to produce a packed spritesheet via Aseprite.

Inputs: session_id (required), columns, padding.

art.aseprite.validateB

Generate a validation Lua script and Aseprite command to check sprite constraints (palette size, dimensions). Writes the script to disk and returns the command.

Inputs: width (required), height (required), max_colors (required), session_id (required).

art.asset.approval.inspectB

Get an approval record by ID.

Inputs: approval_id (required).

art.asset.approval.requestC

Request approval for a candidate asset.

Inputs: actor (required), style (required), asset_id (required), candidate_id (required), +3 more.

art.asset.approveC

Approve a candidate asset.

Inputs: actor (required), approval_id (required), reason.

art.asset.archiveB

Archive an asset (remove from active use).

Inputs: id (required).

art.asset.archive_versionC

Archive a canonical asset, removing it from active use.

Inputs: actor (required), asset_id (required).

art.asset.compareB

Compare two versions of an asset.

Inputs: asset_id (required), version_a (required), version_b (required).

art.asset.currentB

Get the canonical (current) version number of an asset.

Inputs: asset_id (required).

art.asset.deprecateC

Mark an asset as deprecated.

Inputs: id (required).

art.asset.existsA

Check whether an asset with the given ID exists in the registry.

Inputs: id (required).

art.asset.findA

Search and filter registered assets. All parameters are optional; omit all to return every asset.

Inputs: tags, type, status, category, +2 more.

art.asset.getA

Get a registered asset by its ID. Returns the full asset record.

Inputs: id (required).

art.asset.historyC

Get the full version history of an asset.

Inputs: asset_id (required).

art.asset.inspect_versionB

Get details of a specific asset version.

Inputs: version (required), asset_id (required).

art.asset.promoteC

Promote an approved candidate to become the canonical version.

Inputs: actor (required), style (required), approval_id (required), artifact_id (required), +7 more.

art.asset.provenanceC

Get version provenance including approval record.

Inputs: version (required), asset_id (required).

art.asset.rebuild_indexA

Rebuild the asset registry index from all registered asset files.

Inputs: no named parameters.

art.asset.registerA

Register a new asset in the registry. Validates schema, style reference, source file, and relationships.

Inputs: id (required), name (required), type (required), style (required), +8 more.

art.asset.rejectC

Reject a candidate asset.

Inputs: actor (required), approval_id (required), reason, feedback.

art.asset.request_changesC

Request changes on a candidate asset.

Inputs: actor (required), feedback (required), approval_id (required), reason.

art.asset.rollbackB

Rollback the canonical version to a previous version.

Inputs: actor (required), asset_id (required), target_version (required), expected_current_version (required).

art.asset.updateC

Update an existing asset. Provide the asset ID and a patch object with fields to change.

Inputs: id (required), patch (required).

art.canvas.analyze_refA

Analyze a reference image: extract dimensions, color palette with counts, and 2D color map.

Inputs: image_path (required).

art.canvas.batch_drawA

Execute multiple draw commands in a single call for efficiency. Each command references a canvas tool name and its params.

Inputs: commands (required), session_id (required).

art.canvas.clearB

Clear the entire canvas, optionally filling with a color.

Inputs: session_id (required), color.

art.canvas.createB

Create a new pixel canvas session for drawing.

Inputs: session_id (required), width, height, asset_id, +1 more.

art.canvas.draw_circleB

Draw a circle on the canvas.

Inputs: cx (required), cy (required), color (required), radius (required), +2 more.

art.canvas.draw_ditherB

Apply a dither pattern to a rectangular region.

Inputs: x (required), y (required), width (required), color1 (required), +4 more.

art.canvas.draw_lineA

Draw a line between two points using Bresenham algorithm.

Inputs: x0 (required), x1 (required), y0 (required), y1 (required), +2 more.

art.canvas.draw_noiseC

Fill a region with random noise using specified colors.

Inputs: x (required), y (required), width (required), colors (required), +3 more.

art.canvas.draw_rectB

Draw a rectangle on the canvas.

Inputs: x (required), y (required), color (required), width (required), +3 more.

art.canvas.fillB

Flood fill an area starting from a point.

Inputs: x (required), y (required), color (required), session_id (required).

art.canvas.get_pixelB

Read the color of a single pixel on the canvas.

Inputs: x (required), y (required), session_id (required).

art.canvas.get_stateA

Get the current canvas state as a color map (2D hex array) or base64 PNG.

Inputs: session_id (required), format.

art.canvas.saveA

Save the current canvas to a PNG file.

Inputs: session_id (required), output_path.

art.canvas.set_pixelB

Set a single pixel on the canvas.

Inputs: x (required), y (required), color (required), session_id (required).

art.critic.evaluateB

Run the art critic to evaluate canvas quality with spatial scoring and issue detection.

Inputs: session_id (required), profile.

art.critic.refineC

Execute refinement actions from a critique to improve canvas quality.

Inputs: actions (required), session_id (required).

art.detail.cavityB

Add cavity details (dark center with light rim) to a region.

Inputs: x (required), y (required), seed (required), count (required), +5 more.

art.detail.clean_clustersC

Cleanup pass: merge orphan/isolated pixels into nearest larger cluster.

Inputs: session_id (required), min_cluster_size.

art.detail.clusterC

Create a pixel cluster on the canvas at a given position with a specified shape.

Inputs: cx (required), cy (required), size (required), color (required), +3 more.

art.detail.crackB

Add crack patterns to a region (stone, ice surfaces).

Inputs: x (required), y (required), seed (required), color (required), +4 more.

art.detail.edge_breakB

Apply edge breakup to avoid perfectly geometric silhouettes.

Inputs: seed (required), amount (required), session_id (required), preserve_outline.

art.detail.executeC

Run the full detail pass pipeline on an existing canvas session. Requires content already drawn on canvas.

Inputs: materials (required), session_id (required), seed, profile.

art.detail.grainA

Add directional grain lines to a region (wood, cloth).

Inputs: x (required), y (required), seed (required), color (required), +5 more.

art.detail.highlightC

Add highlight clusters to a region for specular/light reflection.

Inputs: x (required), y (required), seed (required), color (required), +4 more.

art.detail.materialB

Apply a full material treatment (all texture patterns for that material) to a region.

Inputs: x (required), y (required), seed (required), width (required), +3 more.

art.detail.passC

Run a single named detail pass on a canvas session.

Inputs: materials (required), pass_name (required), session_id (required).

art.detail.planB

Create a detail art plan for an asset, specifying subject, resolution, materials, and detail profile.

Inputs: width (required), height (required), subject (required), materials (required), +2 more.

art.detail.shadowA

Add shadow clusters to a region for depth/occlusion.

Inputs: x (required), y (required), seed (required), color (required), +4 more.

art.detail.speckleA

Add scattered speckle dots to a region (dirt, stone, skin).

Inputs: x (required), y (required), seed (required), width (required), +4 more.

art.detail.textureC

Apply a texture pattern to a rectangular region on the canvas.

Inputs: x (required), y (required), seed (required), width (required), +5 more.

art.get_paletteB

Returns the color palette for the active style.

Inputs: no named parameters.

art.get_project_contextA

Returns the full art context: project config, active style definition, all rule categories, and palette.

Inputs: no named parameters.

art.get_styleA

Returns the active style definition. Optionally specify style_id and version to look up a specific style.

Inputs: version, style_id.

art.get_style_rulesB

Returns the rules for a specific category of the active style.

Inputs: category (required).

art.memory.add_anchorC

Add a new style anchor to the art memory.

Inputs: id (required), name (required), style (required), assets (required), +6 more.

art.memory.add_decisionC

Add a new art decision record to the art memory.

Inputs: id (required), style (required), title (required), reason (required), +6 more.

art.memory.add_referenceC

Add a new approved reference to the art memory.

Inputs: id (required), roles (required), style (required), status (required), +5 more.

art.memory.add_rejectionB

Add a new rejection record to the art memory.

Inputs: id (required), type (required), style (required), status (required), +5 more.

art.memory.explain_styleA

Explain the current or specified style: core rules, canonical anchors, important decisions, things to avoid, and history.

Inputs: style_id, style_version.

art.memory.find_anchorsC

Search for style anchors with optional filters.

Inputs: status, category, style_id, dimension, +1 more.

art.memory.find_decisionsB

Search for art decision records with optional filters.

Inputs: status, style_id, style_version.

art.memory.find_referencesC

Search for approved references with optional filters.

Inputs: role, status, asset_id, style_id, +1 more.

art.memory.find_rejectionsC

Search for rejection records with optional filters.

Inputs: type, reason, status, style_id, +1 more.

art.memory.get_anchorA

Get a style anchor by its ID.

Inputs: id (required).

art.memory.get_decisionA

Get an art decision record by its ID.

Inputs: id (required).

art.memory.get_referenceC

Get an approved reference by its ID.

Inputs: id (required).

art.memory.get_rejectionA

Get a rejection record by its ID.

Inputs: id (required).

art.memory.get_style_historyB

Get the full style evolution history.

Inputs: no named parameters.

art.memory.get_summaryA

Get a summary of the art memory: anchor count, active decisions, active rejections, total references.

Inputs: no named parameters.

art.memory.insightsA

Get style insights derived from approved assets — patterns, preferences, and learned conventions from the asset corpus.

Inputs: no named parameters.

art.memory.negativeA

Get negative patterns (rejected examples) for a type/material — query rejections filtered by type hints in reasons.

Inputs: type, material.

art.memory.resolve_referencesD

Resolve relevant references, anchors, decisions, and rejections for a given context. Returns categorized results.

Inputs: type, category, style_id, dimensions, +1 more.

art.memory.signatureA

Compute a visual signature (deterministic fingerprint) for a canvas session — color distribution, cluster stats, edge complexity, etc.

Inputs: session_id (required).

art.pipeline.analyzeB

Analyze a reference image. Returns palette, silhouette, composition, pixel characteristics. Provide either a file path or reference_id of an already-uploaded reference.

Inputs: pose, facing, subject, category, +2 more.

art.pipeline.planA

Build a 7-stage ArtPlan (silhouette-first) from an ArtSpecification. The plan defines ordered generation stages with QA checkpoints.

Inputs: reference_id (required), max_iterations.

art.pipeline.scoreC

Compute visual quality score for a pixel art asset. Scores silhouette, palette, composition, pixel cleanliness, and style match.

Inputs: asset_path (required), reference_id.

art.pipeline.specB

Build an ArtSpecification from a reference analysis + active style. The spec defines canvas, palette, outline, shading constraints for pixel art generation.

Inputs: reference_id (required), subject, max_colors, canvas_width, +1 more.

art.production.approveB

Approve a production job that is awaiting approval, moving it to completed.

Inputs: job_id (required).

art.production.attemptsB

Get the attempt history for a production job.

Inputs: job_id (required).

art.production.cancelC

Cancel a production job.

Inputs: job_id (required).

art.production.createB

Create a production job (plan + persist, does not start execution).

Inputs: output (required), subject (required), asset_type (required), request_id (required), +5 more.

art.production.inspectC

Get full details of a production job including events, attempts, and plan.

Inputs: job_id (required).

art.production.listB

List all production job IDs.

Inputs: no named parameters.

art.production.planB

Create a production plan for an art asset (inspect before executing).

Inputs: output (required), subject (required), asset_type (required), request_id (required), +5 more.

art.production.resumeA

Resume a failed or interrupted production job.

Inputs: job_id (required).

art.production.startC

Start executing a production job.

Inputs: job_id (required).

art.production.statusC

Get the current status of a production job.

Inputs: job_id (required).

art.provider.analyzeB

Analyze a PNG file using the canvas-analysis provider. Runs local analysis (signature, clusters, palette) without external APIs.

Inputs: operation (required), source_path (required), style, asset_id, +2 more.

art.provider.artifactB

Get details of a generated artifact.

Inputs: artifact_id (required).

art.provider.cancelC

Cancel a running provider operation.

Inputs: operation_id (required).

art.provider.capabilitiesB

Get the capabilities of a specific provider.

Inputs: provider_id (required).

art.provider.executeC

Execute an art generation operation via a provider.

Inputs: style (required), operation (required), provider_id (required), output, +6 more.

art.provider.fallbackC

Execute an art operation with fallback — tries the primary provider, falls back to a secondary on failure.

Inputs: style (required), operation (required), provider_id (required), output, +7 more.

art.provider.getA

Get detailed metadata for a specific provider.

Inputs: provider_id (required).

art.provider.healthB

Check the health status of a specific provider.

Inputs: provider_id (required).

art.provider.health_allA

Check health of all registered providers. Returns a map of provider ID to health status with latency and consecutive failure count.

Inputs: no named parameters.

art.provider.listA

List all registered art providers with their metadata.

Inputs: no named parameters.

art.provider.operationC

Get the status of a provider operation.

Inputs: operation_id (required).

art.qa.assetA

Run QA checks on a single asset. Returns a full QA report with all rule results.

Inputs: asset_id (required), profile.

art.qa.batchA

Run QA checks on multiple assets at once. Returns a batch report with individual results.

Inputs: asset_ids (required), profile.

art.qa.explain_failureA

Explain why a specific QA rule failed for an asset. Returns rule definition, issue details, and context.

Inputs: rule_id (required), asset_id (required).

art.qa.gateB

Run a QA gate check on an asset. Returns pass/fail verdict with full report.

Inputs: asset_id (required), profile.

art.qa.historyC

Get QA run history. Optionally filter by asset ID.

Inputs: asset_id.

art.qa.list_rulesA

List all available QA rules with their definitions.

Inputs: no named parameters.

art.qa.ruleA

Get the full definition of a specific QA rule by its ID.

Inputs: rule_id (required).

art.ref.canonicalA

Get canonical assets for a type/material — filters retrieve results to only canonical status entries.

Inputs: type, material.

art.ref.packB

Build a reference pack for generation — combines style constraints, canonical references, negative examples, and material palette.

Inputs: type, category, material, max_negative, +1 more.

art.ref.retrieveB

Smart ranked reference retrieval — scores and returns top assets by canonical status, style match, material match, and recency.

Inputs: type, category, material, max_results.

art.style.bootstrapA

Get session bootstrap context — assembles project config, style, canonical assets, anti-patterns, and recent decisions into one payload.

Inputs: no named parameters.

art.style.checkA

Run style consistency check on a canvas session — compares canvas content against compiled style constraints.

Inputs: session_id (required), material.

art.style.compileB

Compile style constraints for a subject — merges style definition, optional material profile, and resolution into a flat StyleConstraints object.

Inputs: width, height, profile, material.

art.style.repairA

Generate a repair plan from a style consistency check — identifies actions to fix style issues on a canvas.

Inputs: session_id (required), material.

art.tilemap.build_opsB

Generate TiledMCP operations from a MapSpecification. Returns the operation sequence for TiledMCP provider execution.

Inputs: map_id (required).

art.tilemap.create_specC

Create a MapSpecification for tilemap generation. Defines map size, biome, layers, objects, terrain rules.

Inputs: biome (required), width (required), height (required), layers (required), +6 more.

art.tilemap.list_tilesetsA

List all registered tileset definitions.

Inputs: no named parameters.

art.tilemap.register_tilesetB

Register a tileset definition with semantic tile metadata. Each tile gets an ID, terrain, walkability, collision info.

Inputs: tiles (required), asset_id (required), tile_size (required), tileset_id (required), +2 more.

art.tilemap.resolve_tilesA

Resolve semantic tile names to tileset local IDs. Use to verify tile names before building a map.

Inputs: intents (required), tileset_id (required).

art.tilemap.validateA

Validate a MapSpecification against its tileset. Checks missing tiles, invalid refs, style mismatch, object bounds.

Inputs: map_id (required).

art.validate_styleB

Validates the active style configuration and returns any errors found.

Inputs: no named parameters.

art.workflow.guideA

Generate a step-by-step painting guide for the AI to follow when drawing a subject. Enforces strict palette discipline, form-first/detail-last hierarchy, and per-step color limits. The guide is TEXT instructions — read it and follow each step sequentially.

Inputs: subject (required), width, height, profile, +1 more.

art.workflow.paletteA

Get the strict palette for a material — returns role-to-hex mappings, maximum color count, and forbidden colors. Use this before painting to know EXACTLY which colors are allowed.

Inputs: material.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.9/5.0

    Scored across 126 tools

    Disambiguation3/5

    The hierarchical namespaces help, but the sheer number of tools creates real overlap: art.provider.analyze vs art.pipeline.analyze, art.asset.archive vs art.asset.archive_version, and art.qa.asset vs art.critic.evaluate vs art.style.check all have fuzzy boundaries. An agent could easily pick the wrong one without very careful descriptions.

    Naming Consistency4/5

    Most tools follow a predictable art.<category>.<action> pattern with snake_case verbs, which is highly readable. However, a few top-level tools like art.validate_style, art.get_style, and art.get_palette break the convention, and verbs are mixed across add/register/create for similar operations.

    Tool Count1/5

    126 tools is an extreme count for any MCP server, far beyond the 25+ threshold. Many micro-tools—individual detail effects, memory CRUD variants, and Aseprite command generators—could be consolidated into broader operations, making the surface unnecessarily hard to navigate.

    Completeness5/5

    The tool surface is remarkably comprehensive for a game-art domain: asset lifecycle, versioning, approvals, style memory, QA, providers, canvas painting, production jobs, tilemaps, detail passes, Aseprite export, and workflow guidance are all covered. Major workflows have no obvious dead ends.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI coding agents to create, draw, and refine Aseprite documents through deterministic canvas, layer, frame, tag, and palette tools, with pixel analyzers, style validation, and preview/diff visual feedback. It also supports spritesheet and animated GIF export, producing multi-layer game-ready assets.
      1
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables users to automate the creation, editing, animation, and export of pixel-art game assets through a multi-agent pipeline that derives style specs and blueprints, generates Lua build scripts, and drives the canvas editor to produce .aseprite files, spritesheets, atlases, GIFs, and previews.
      12
      3
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to create and edit pixel-art projects — sprites, props, palettes, eight-direction animation, and tile-based environments — through a stdio MCP server with discovery, help, and call tools. Agents can build from silhouette to detail, inspect native-scale renders, silhouettes, value maps, and GIF playback, then save every change as versionable source.
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables MCP-capable coding agents to act as a deterministic technical art director and multi-engine pipeline builder, locking AI-generated 2D/2.5D game assets to consistent camera angles, palettes, rigs, atlases, and exports across Blender, ComfyUI, UniRig, LibreSprite, Godot 4, Unity, and Unreal Engine 5.
      24
      MIT