Skip to main content
Glama
game-art-mcp

game-art-mcp

by Cuvara

game-art-mcp

2D RPG 게임 아트 방향성을 위한 AI 기반 픽셀 아트 스타일 시스템 및 MCP 서버.

목적

이 저장소는 프로젝트 아트 방향성에 대한 진실의 원천(source of truth) 입니다. 모든 AI 에이전트는 이 저장소에 접근하여 MCP를 통해 프로젝트 컨텍스트를 조회하고, 대화 기록에 의존하지 않고도 "우리의 아트 스타일"이 무엇을 의미하는지 정확히 이해할 수 있습니다.

Related MCP server: Aseprite MCP Server

아키텍처

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

빠른 시작

npm install
npm run build
npm test

MCP 서버 실행

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

스타일 검증

npm run validate

MCP 도구

스타일 도구(읽기 전용)

도구

설명

art.get_project_context

전체 아트 컨텍스트(프로젝트 + 스타일 + 모든 규칙)

art.get_style

활성 스타일 정의

art.get_style_rules

특정 규칙 카테고리(pixel_language, outline 등)

art.get_palette

의미론적 역할이 포함된 색상 팔레트

art.validate_style

스타일 구성 검증

에셋 도구(읽기 + 쓰기)

도구

설명

art.asset.get

ID로 에셋 조회

art.asset.find

에셋 검색/필터링(유형, 카테고리, 상태, 태그)

art.asset.exists

에셋 ID가 등록되어 있는지 확인

art.asset.register

전체 검증을 거쳐 새 에셋 등록

art.asset.update

기존 에셋 업데이트(부분 패치)

art.asset.deprecate

에셋을 더 이상 사용하지 않음으로 표시

art.asset.archive

에셋 보관 처리

art.asset.rebuild_index

에셋 파일에서 레지스트리 인덱스 재구축

메모리 도구(읽기 + 쓰기)

도구

설명

art.memory.get_summary

메모리 개요: 앵커, 결정, 거부 사항, 참조 횟수

art.memory.explain_style

규칙, 앵커, 결정, 회피 사항을 포함한 전체 스타일 설명

art.memory.resolve_references

주어진 컨텍스트에 대한 결정적 참조 조회

art.memory.get_anchor

ID로 스타일 앵커 조회

art.memory.find_anchors

앵커 검색(카테고리, 상태, 차원 필터)

art.memory.add_anchor

새 스타일 앵커 추가

art.memory.get_reference

ID로 승인된 참조 조회

art.memory.find_references

참조 검색(역할, 상태, asset_id 필터)

art.memory.add_reference

새 승인 참조 추가

art.memory.get_rejection

ID로 거부 기록 조회

art.memory.find_rejections

거부 사항 검색(유형, 상태, 사유 필터)

art.memory.add_rejection

새 거부 기록 추가

art.memory.get_decision

ID로 아트 결정 조회

art.memory.find_decisions

결정 검색(상태 필터)

art.memory.add_decision

새 아트 결정 추가

art.memory.get_style_history

전체 스타일 변천 이력 조회

QA 도구(읽기 전용)

도구

설명

art.qa.asset

단일 에셋에 대한 QA 검사 실행(전체 보고서)

art.qa.batch

여러 에셋에 대한 QA 검사 실행(배치 보고서)

art.qa.gate

QA 게이트 — 승인 워크플로우용 통과/실패 판정

art.qa.list_rules

정의와 함께 사용 가능한 모든 QA 규칙 나열

art.qa.rule

ID로 특정 QA 규칙의 전체 정의 조회

art.qa.explain_failure

특정 규칙이 에셋에서 실패한 이유 설명

art.qa.history

에셋 ID로 필터링된 QA 실행 이력 조회

공급자 도구(읽기 + 쓰기)

도구

설명

art.provider.list

메타데이터와 함께 등록된 모든 공급자 나열

art.provider.get

특정 공급자의 상세 메타데이터 조회

art.provider.capabilities

공급자 역량 조회(작업, 형식, 제한 사항)

art.provider.health

공급자 상태 확인

art.provider.execute

공급자를 통한 아트 생성 작업 실행

art.provider.cancel

실행 중인 공급자 작업 취소

art.provider.operation

ID로 작업 상태 조회

art.provider.artifact

ID로 아티팩트 세부 정보 및 출처 조회

프로덕션 도구(읽기 + 쓰기)

도구

설명

art.production.plan

프로덕션 계획 수립(실행 전 미리보기)

art.production.create

프로덕션 작업 생성(계획 + 유지, 즉시 시작 안 함)

art.production.start

프로덕션 작업 실행 시작

art.production.status

현재 작업 상태 조회(요약)

art.production.inspect

전체 작업 세부 정보 조회(이벤트, 시도, 계획)

art.production.resume

실패한 작업 재개

art.production.cancel

실행 중인 작업 취소

art.production.attempts

작업 시도 이력 조회

art.production.approve

승인 대기 중인 작업 승인

art.production.list

모든 프로덕션 작업 ID 나열

버전 관리 도구(읽기 + 쓰기)

도구

설명

art.asset.current

에셋의 현재(정식) 버전 조회

art.asset.inspect_version

특정 에셋 버전의 세부 정보 조회

art.asset.history

에셋의 전체 버전 이력 조회

art.asset.compare

동일 에셋의 두 버전 비교

art.asset.provenance

승인 기록을 포함한 버전 출처 조회

art.asset.approval.request

후보 에셋에 대한 승인 요청

art.asset.approval.inspect

ID로 승인 기록 조회

art.asset.approve

후보 에셋 승인

art.asset.reject

후보 에셋 거부

art.asset.request_changes

후보 에셋에 대한 변경 요청

art.asset.promote

승인된 후보를 정식 버전으로 승격

art.asset.rollback

정식 버전을 이전 버전으로 롤백

art.asset.archive_version

정식 에셋 보관 처리

스타일 및 QA 도구는 읽기 전용입니다. 에셋, 메모리, 공급자, 프로덕션, 버전 관리 도구는 읽기와 쓰기를 모두 지원합니다.

에셋 레지스트리

에셋 레지스트리(2단계)는 구조화된 메타데이터로 프로젝트의 모든 아트 에셋을 추적합니다. 에셋은 registry/assets/ 디렉토리에 개별 YAML 파일로 저장되며 registry/registry.yaml에 인덱싱됩니다.

주요 기능:

  • 의미론적 ID — 점으로 구분된 소문자 (예: character.goblin.001)

  • 스타일 연결 — 모든 에셋은 스타일 ID + 버전을 참조

  • 관계 — variant_of, derived_from, animation_of 등

  • 상태 추적 — 초안, 승인됨, 거부됨, 더 이상 사용 안 함, 보관됨

  • 전체 검증 — 스키마, 스타일 참조, 소스 파일 존재, 관계

전체 문서는 docs/ASSET-REGISTRY.md를, 메타데이터 스키마는 docs/ASSET-METADATA.md를 참조하세요.

아트 메모리

아트 메모리 시스템(3단계)은 저장소에 지속적인 시각적 지식을 제공합니다. 무엇이 승인되었고, 무엇이 거부되었으며, 그 이유가 무엇인지 기억하므로 에이전트는 프로젝트의 아트 방향성을 이해하기 위해 대화 기록이 필요하지 않습니다.

주요 개념:

  • 스타일 앵커 — 스타일을 정의하는 표준 시각적 예시 ( docs/STYLE-ANCHORS.md 참조)

  • 승인된 참조 — 역할과 차원이 있는 신뢰할 수 있는 에셋

  • 거부 사항 — 스타일에 맞지 않는 것, 통제된 사유 어휘와 함께

  • 아트 결정 — 시각적 방향성 선택에 대한 ADR 형식 기록 ( docs/ART-DECISIONS.md 참조)

  • 참조 해석기 — 모든 생성 작업에 관련 컨텍스트를 반환하는 결정적 조회

전체 문서는 docs/ART-MEMORY.md를 참조하세요.

아트 QA

아트 QA 시스템(4단계)은 픽셀 아트 에셋에 대한 결정적이고 재현 가능한 품질 게이트를 제공합니다. 모든 검사는 기대값/실제값과 구조화된 개선 조치가 있는 규칙 기반입니다 — AI 비전, 임베딩, 자동 복구 없음.

주요 개념:

  • 13개 규칙, 7개 카테고리(기술, 차원, 팔레트, 알파, 픽셀, 스타일, 메모리)

  • 3개 프로필 — 엄격(경고 시 실패), 기본(오류 시 실패), 관대(치명적일 때만 실패)

  • 기계 판독 가능 보고서 — 규칙별 결과, 심각도, 개선 조치가 포함된 JSON

  • 스타일 통합 — 활성 스타일에서 캔버스 크기, 팔레트 제한, 픽셀 규칙 읽기

  • 메모리 통합 — 거부된 방향성과 승인된 아트 결정 확인

  • QA 게이트 — CI 및 승인 워크플로우용 통과/실패 판정

  • QA 이력 — 에셋별 모든 실행의 영구 로그

전체 문서는 docs/ART-QA.md를 참조하세요.

공급자 어댑터

공급자 어댑터 시스템(5단계)은 외부 아트 생성 도구에 대한 공급자 중립 인터페이스를 추가합니다. 요청은 게이트웨이를 통해 흐르며, 게이트웨이는 작업을 검증하고 등록된 어댑터에 위임하며, 변경 불가능한 출처와 함께 생성된 아티팩트를 저장합니다.

주요 개념:

  • ProviderAdapter 인터페이스 — 메타데이터, 역량, 상태, 실행, 취소

  • 아티팩트 — 변경 불가능한 출처가 있는 원시 공급자 출력(아직 에셋이 아님)

  • 역량 — 작업별 세부 정보(형식, 최대 해상도)

  • 드라이런 — 출력을 생성하지 않고 요청 검증

  • 목 공급자 — 실패/시간 초과 모드가 있는 내장 테스트 어댑터

  • 자동 선택 없음 — 에이전트는 공급자를 명시적으로 선택해야 함

전체 문서는 docs/PROVIDERS.md를 참조하세요.

프로덕션 오케스트레이터

프로덕션 오케스트레이터(6단계)는 전체 아트 에셋 생성 수명 주기를 조정합니다: 요청 검증, 스타일/참조/공급자 해석, 실행, QA, 재시도, 승인 게이팅.

주요 개념:

  • 코디네이터이지 진실의 원천이 아님 — 스타일, QA, 공급자, 레지스트리에 위임

  • 상태 머신 — 검증된 전환을 가진 9가지 상태 (created부터 completed/failed/cancelled까지)

  • 11개 프로덕션 단계 — REQUEST_VALIDATION부터 APPROVAL_GATE까지

  • 제한된 재시도 — 구성 가능한 max_attempts(기본값 3) 및 QA 실패 시 복구 계획

  • 승인 경계 — awaiting_approval에서 중지되며, 자동 승인하지 않음

  • 계획 지연 감지 — 실행 전 스타일 버전 드리프트 감지

  • YAML 영속성 — production/<job_id>/에 작업당 manifest.yaml 하나

  • 이벤트 기록 — 작업별 모든 상태 변경의 추가 전용 로그

전체 문서는 docs/PRODUCTION.md를 참조하세요.

버전 관리 및 승인

버전 관리 및 승인 시스템(Phase 7)은 불변 자산 버전 관리, 명시적 승인 워크플로, 전체 감사 추적을 추가합니다. 어떤 버전도 삭제되지 않으며, 어떤 자산도 자동 승인되지 않습니다.

핵심 개념:

  • 자산 수명 주기 — 8가지 상태: draft, pending_approval, approved, rejected, changes_requested, promoted, superseded, archived

  • 승인 워크플로 — 구조화된 피드백과 함께 request, approve, reject, request_changes

  • 승인 정책 — 구성 가능: requires_qa_pass, allow_agent_approval, requires_human

  • 불변 버전 — 단조 증가, 부모 추적, 버전별 전체 출처

  • 표준 포인터 — 현재 버전을 추적하며, 승격/롤백 시 업데이트

  • 승격 — QA 게이트 및 승인 게이트가 있는 compare-and-swap

  • 롤백 — 표준을 이전 버전으로 다시 지정하며, 기록을 삭제하지 않음

  • 감사 로그 — 9가지 이벤트 유형, 추가 전용, 불변

  • 행위자 식별 — 모든 레코드에서 human, agent, system, provider 추적

전체 문서는 docs/VERSIONING.md를 참조하세요.

현재 단계

Phase 7 — 버전 관리 및 승인 (완료)

전체 로드맵은 docs/PHASES.md를 참조하세요.

스타일 시스템

스타일은 기계가 읽을 수 있는 아트 디렉션을 나타내는 구조화된 YAML 파일입니다:

  • style.yaml — 정체성, 캔버스 크기, 스케일링

  • palette.yaml — 의미적 역할을 가진 색상

  • pixel-rules.yaml — 픽셀 아트 제약

  • outline.yaml — 윤곽선 규칙

  • shape-language.yaml — 시각적 언어

  • lighting.yaml — 조명 방향 및 규칙

  • animation.yaml — 프레임 수, FPS, 제약

자세한 내용은 docs/STYLE-SYSTEM.md를 참조하세요.

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