Skip to main content
Glama
Sign In
schematic-architect

schematic-architect

by BarnieBarnie
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Local

schematic-architect

An MCP server that lets an AI agent design Minecraft builds from a player's prompt ("make a giant cross from oak") and export them as Litematica schematics (.litematic).

It was made for AntCraft, whose bots build any .litematic in a data pack, but the files work with Litematica too.

How it works

The agent never places blocks one by one. It draws with shapes (box, line, cylinder, sphere, pyramid), edits (clear, replace, copy, symmetrize, undo), looks at what it made (preview returns a picture, layer a text grid), checks the cost (materials) and exports.

Blocks are painted with palette roles (primary, secondary, trim, accent, glass, roof, floor, light) or with plain block states (oak_log, minecraft:oak_stairs[facing=north]). A palette names the block each role builds as, so one design is built from oak early in the game and from quartz later:

Tier

Palettes

early

oak, spruce, birch, cobble, sandstone

mid

stone_brick, brick, deepslate, copper

late

quartz, blackstone, prismarine, purpur

The palettes live in palettes.toml.

Related MCP server: minecraft-mcp-server-blueprint

Install

With uv, add it to your MCP client. For Claude Code:

claude mcp add schematic-architect -- uvx --from git+https://github.com/BarnieBarnie/schematic-architect schematic-architect

For Claude Desktop, in claude_desktop_config.json:

{
  "mcpServers": {
    "schematic-architect": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/BarnieBarnie/schematic-architect", "schematic-architect"]
    }
  }
}

Use it

Ask the agent, naming the world's data pack folder:

Design a giant cross from oak and export it to ~/.minecraft/saves/MyWorld/datapacks/architect.

The agent writes datapacks/architect/data/architect/blueprint/cross.litematic (and a pack.mcmeta if the pack has none). In game, run /reload. With AntCraft the build is now blueprint architect:cross: pick it with the Blueprint item to see its ghost, and a bot builds it with build("architect:cross", at).

Later in the game: "rebuild the cross in quartz" swaps the palette with set_palette and exports again.

open_schematic loads an existing .litematic to change it.

Good to know

  • Every position inside the build's bounds that holds no block is structure void: a bot building it leaves what stands there and can put scaffolding through it. A hollow dome built into a hill is not dug out inside.

  • AntCraft's ghost shows at most 4096 blocks of a build; bots build all of it.

  • Block names are not checked against the game: a misspelt block becomes air when the game loads the file.

  • Turning and mirroring (copy, symmetrize) turn facing, axis and sign rotation; stair corner shapes and fences keep their sides.

  • The previews use flat colours guessed from block names, not the game's textures.

  • Designs live in the server's memory for the session; export to keep them.

Develop

uv sync
uv run pytest

The tests read every exported file back, and also with litemapy, an independent reader, so the files load in Litematica and AntCraft.

Available Tools

20 tools
boxB

Fills a box between two corners: mode solid, shell (six faces, hollow inside), walls (four sides, no floor or roof) or frame (the twelve edges).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +5 more. Returns: result

clearA

Removes every block in a box (doors, windows, hollowing out).

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +3 more. Returns: result

copyB

Copies the blocks of a box dx, dy, dz on (repeat a window, a pillar, a wing), mirrored ("x" or "z") and turned a quarter clockwise (seen from above) turns times within the box. Facing and axis states turn with them.

Inputs: dx (required), dy (required), dz (required), x1 (required), +8 more. Returns: result

cylinderB

A cylinder whose first end is centred on x, y, z, running length blocks along +axis (y: a tower, x or z: a tunnel or arch). hollow leaves a tube open at both ends.

Inputs: x (required), y (required), z (required), block (required), +5 more. Returns: result

exportB

Writes the design as data//blueprint/.litematic in a data pack folder, such as /datapacks/architect, making the pack's pack.mcmeta if it has none. After /reload in game it is blueprint :: pick it with the Blueprint item, and bots build it with build(":", at). A path ending in .litematic writes just that file instead.

Inputs: design (required), datapack (required), namespace, description. Returns: result

layerB

One height of the design as text, from above (north up, x to the right), y counted from the bottom; a letter a block, "." air. For checking exact positions.

Inputs: y (required), design (required). Returns: result

lineC

A one-block line between two points, diagonal too.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +4 more. Returns: result

list_designsB

The designs open in this session, with their palette, size and block count.

Inputs: no named parameters. Returns: result

materialsC

What the design takes to build: blocks with counts, stacks and tier, and the highest tier it needs.

Inputs: design (required). Returns: result

new_designB

Starts an empty design named design (lowercase letters, digits, _ . -; it becomes the blueprint id) with a palette.

Inputs: design (required), palette. Returns: result

open_schematicB

Opens a .litematic file as a design to change, its blocks as they are (no roles).

Inputs: path (required), design. Returns: result

palettesC

The palettes, by tier, with the block each role builds as.

Inputs: no named parameters. Returns: result

previewB

A picture of the design: "all" (isometric beside top, front and side), "iso", "top", "front" (from the south), "side" (from the east), or "layer" with y (one height, from above, y counted from the bottom of the design). Colours are guessed from block names; glass is see-through.

Inputs: design (required), y, view.

pyramidB

A stepped pyramid on the rectangle x1..x2, z1..z2 starting at height y, one smaller on every side each layer up. Also good for a stepped roof.

Inputs: y (required), x1 (required), x2 (required), z1 (required), +4 more. Returns: result

replaceC

Swaps every old block or role for new; a block name without state matches all its states.

Inputs: new (required), old (required), design (required). Returns: result

set_blockC

Puts one block (a role, a block state, or air).

Inputs: x (required), y (required), z (required), block (required), +1 more. Returns: result

set_paletteC

Builds the design's roles from another palette, such as a late-game one; literal blocks stay as they are.

Inputs: design (required), palette (required). Returns: result

sphereB

A ball centred on x, y, z. half "top" keeps the upper half (a dome), "bottom" the lower (a bowl).

Inputs: x (required), y (required), z (required), block (required), +4 more. Returns: result

symmetrizeA

Makes the design symmetric across a plane: the low side (smaller x or z) is mirrored onto the high side. center is the plane's x or z; the middle of the design by default.

Inputs: axis (required), design (required), center. Returns: result

undoC

Takes back the last change (up to 20).

Inputs: design (required). Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    Deploy Server
    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

    TDQS

    B3/5.0

    Scored across 20 tools

    Disambiguation4/5

    Most tools target a clearly distinct resource or operation: the five shape primitives (box, line, cylinder, sphere, pyramid), the block-level edits (set_block, clear, replace), and the design lifecycle tools are easy to tell apart. The only mild overlaps are box vs clear vs replace (all act on a box region) and copy vs symmetrize (both mirror geometry), but their descriptions spell out the differences well enough for an agent to choose correctly.

    Naming Consistency3/5

    There is a rough logic (shape primitives are bare nouns, design management uses verb_noun like new_design, list_designs, set_palette, set_block), but listing/inspection tools mix conventions: list_designs uses a verb while palettes and materials are bare nouns. It stays readable, but the pattern is not predictable enough to guess a tool name cold.

    Tool Count4/5

    At 20 tools the set is on the heavy side, but nearly every tool maps to a distinct capability of a schematic editor (five shapes, three block edits, palette handling, four inspection/preview tools, export, undo). Nothing looks like filler, though a few could plausibly be folded together (e.g. layer into preview).

    Completeness4/5

    The surface covers the full build loop: create/open/list designs, assign palettes, place and modify geometry, inspect via materials/preview/layer, and export to a datapack. Minor gaps remain: no way to close or delete a design, no rename, no single-block query at a coordinate, and undo has no redo, but agents can work around all of these.

    Resources

    Related MCP Connectors

    Related MCP Servers

    • blockwright

      ThatHunky
      A
      license
      B
      quality
      B
      maintenance
      Enables AI assistants to build and manage Minecraft structures on a live server via RCON, with preview, read-back, and undo capabilities.
      16
      15 npm
      MIT

    • Aldeano Build MCP

      Aldeanoo
      A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to perceive, navigate, interact with, and build inside Minecraft through typed, bounded operations, including deterministic blueprints, verified builds, repair, and creative-mode flight or teleport. Runs as a provider-neutral MCP server or an interactive dev shell, exposing movement, voxel manipulation, inventory, chat, and diagnostics tools.
      3
      Apache 2.0