Skip to main content
Glama
bedrock-map-builder-mcp

bedrock-map-builder-mcp

by xRookieFight

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
MBM_BDS_DIRNoFolder of the unpacked Bedrock Dedicated Server. Optional; can also be configured later via server_setup.
MBM_PROJECTNoProject opened at start.default
MBM_WS_PORTNoPort for /connect.19150
MBM_DATA_DIRNoManaged worlds, backups, and projects directory.~/.local/share/bedrock-map-builder-mcp
MBM_SERVER_PORTNoUDP port of the managed server, join it from the game to look around.19140
MBM_CLIENT_WORLDSNoExtra folders (colon separated) to look for client worlds.
MBM_START_TIMEOUT_MSNoHow long Bedrock Dedicated Server gets to start.180000

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Builds and edits Minecraft: Bedrock Edition maps in a real world.

Connect first. server_status shows what's up. For a world managed here: server_setup once (finds the Bedrock Dedicated Server), then world_create (new) or world_import + server_start (existing world, e.g. from world_list's client section), and world_export to hand it back to the game. For a world open in the game client: ws_listen, then the player types /connect in chat (commands only, no reading back, no undo).

Build with generate (generator_help lists houses, towers, castles, walls, bridges, roads, skyscrapers, cities, arenas, parkour, lobbies, dungeons, trees, vegetation, terrain, sculpt, rivers, lakes, caves, mountains, free form shapes and JS scripts). dry_run with preview shows an image before writing anything. fill_region, replace_blocks, clear_region, place_blocks, copy_region (copy/move/rotate/mirror/stack) and structure_import/export cover direct editing. run_commands, set_world_rules, spawn_entities, fill_container, set_sign and map_functions handle game logic.

Look at the world with view (images), region_stats, find_blocks, list_entities and check_map (spawn safety, reachability, symmetry, floating blocks, dark spots).

Every world edit is journaled and undoable (op_list, op_undo); snapshots live in the project folder, not in the map. For big jobs make a plan (plan_create, plan_run): steps survive restarts and resume where they stopped. Record design decisions with project_note and palette_set so the whole project stays consistent. Block ids are Bedrock ids (block_search, block_info); common Java names are translated automatically.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
server_setupB

Point the builder at an unpacked Linux Bedrock Dedicated Server (the folder with bedrock_server). With detect=true it searches Downloads and similar folders and picks the newest. Also sets the game port players can join on.

server_statusA

What is connected right now: server state, world, BDS version, bridge ping, current project, and the last console lines.

world_listB

Managed worlds (inside the builder's server) and worlds found in the game client folders (mcpelauncher, Windows) that can be imported.

world_createA

Create a new managed world and start the server on it. flat is a superflat build plot, default is normal terrain. Mob spawning, daylight and weather cycles are turned off for building.

server_startA

Start the server on a managed world (stops whatever else was running). The world gets the bridge pack attached automatically.

server_stopA

Stop the server cleanly (it saves the world first).

server_consoleA

Send a raw line to the BDS console and return what it printed for a moment after (for save, list, reload and other console only commands). In-game commands are better sent with run_commands.

world_importA

Copy a world into the builder: a world folder (for example one from world_list's client section) or a .mcworld file. The original stays untouched; use world_export to write changes back.

world_exportA

Write a managed world out: to='source' copies it back over where it was imported from, a path ending in .mcworld makes a file, any other path makes a world folder. Whatever gets overwritten is backed up first, and the bridge pack reference is removed so the client sees a clean world.

world_backupC

Full copy of a managed world. While the server runs it uses save hold/query/resume, so the copy is consistent.

world_backupsC

List world backups.

world_restoreA

Replace a managed world with one of its backups. The current state is backed up first, so this can be undone too.

ws_listenA

Open a WebSocket for a world that's open in the game client. The player then types /connect localhost: in chat (cheats on; turn off "Require Encrypted Websockets" in the game settings if the client has it). Over this link only commands work: building, filling and in-session undo, but no reading back, analysis or export.

ws_statusA

Whether a game client is connected over /connect.

ws_stopB

Close the WebSocket and disconnect the game client.

use_connectionB

Pick which connection the tools act on when both a BDS world and a /connect client are up.

project_openB

Switch to (or create) a project. A project keeps design decisions, the palette, named regions, markers, the undo journal and build plans between sessions.

project_infoB

Everything the current project remembers: decisions, palette, regions, plans with progress, recent ops.

project_noteB

Record a design decision that should hold for the rest of the project (style, scale, colour rules, gameplay constraints). remove takes the index of a note to drop.

region_markC

Name a region (spawn area, arena, district...) so later requests can refer to it by name. Pass only name to delete.

op_listA

Journal of world edits in this project, newest first, with status (done, partial, failed, undone) and whether they can be undone.

op_undoA

Undo an edit by putting back what was there before. Refuses when a later edit overlaps it (undo that first) unless force. Without op_id it undoes the newest edit that isn't undone yet.

plan_createA

Save a multi step build plan (big projects: terrain, then districts, then roads, then details). Steps are ordinary tool calls. Plans survive restarts and plan_run continues where it stopped.

plan_showB

Show a plan with each step's status, results and errors.

plan_listB

Plans in the current project with progress.

plan_editA

Change a plan: append steps, insert after a step, or set a step's status (pending to rerun, skipped to jump over it).

plan_runA

Run a plan's pending steps in order (failed steps are retried). Interrupted world edits resume from the tiles they finished. Stops at the first error unless continue_on_error, and after max_steps so long plans can report progress.

generator_helpA

List the generators with what they build and how origin is used, or the full argument schema of one generator.

generateA

Build something with a generator and write it into the world (undoable), or preview it with dry_run (no world needed). Generators: shapes, script, house, tower, wall, castle, bridge, road, skyscraper, city, arena, parkour, lobby, dungeon, tree, vegetation, terrain, sculpt, river, lake, caves, mountain. Call generator_help for arguments. Returns markers (spawns, doors, chests, checkpoints...) for follow up steps like set_spawn or fill_container. preview adds a rendered image.

place_blocksB

Set individual blocks at exact coordinates (up to 20000). Block names are checked first; states use the [state=value] form.

fill_regionB

Fill a box with a block, a weighted mix ({"stone":3,"andesite":1}) or a palette role (@wall). mode: solid, hollow, walls, outline, floor, ceiling. only_replace limits the fill to those block types, keep protects them.

replace_blocksB

Swap one or more block types for another block or mix inside a box, leaving everything else alone. Matches by block type, states are ignored when matching.

clear_regionC

Set a box to air (keep lets some blocks survive, e.g. bedrock).

copy_regionA

Copy, move, rotate, mirror or repeat a region. dest is where the source's min corner ends up. rotate is quarter turns clockwise (block facing rotates too). repeat > 1 stacks copies every step. move clears the source. skip_air leaves the destination's existing blocks where the source has air. Chest contents and other block entity data are not copied.

structure_exportC

Save a region of the world as a .mcstructure file (the format structure blocks and /structure load use).

structure_importB

Place a .mcstructure file into the world at origin (its min corner), optionally rotated or mirrored. Structure void cells leave the world alone. preview_only renders it without writing.

block_searchA

Find Bedrock block ids by substring, e.g. 'stairs', 'copper', 'glass'.

block_infoB

States and allowed values of a block, with the Bedrock name for Java ids and suggestions for typos.

palette_setA

Set project wide palette roles (wall, roof, floor, trim, light, path, ...) so every later build keeps the same look. Values are blocks or weighted mixes. Pass null to remove a role.

run_commandsA

Run Bedrock commands in the world (setblock, fill, summon, tp, gamerule, scoreboard, tag, effect, time, weather, structure...). Each command reports success or the game's error text. Bedrock syntax, not Java: e.g. block states use ["state"=value] and there's no NBT. Commands that touch blocks far from players need load_area covering them, otherwise they quietly affect nothing (count 0).

set_world_rulesC

Set the world spawn point and any gamerules in one go (e.g. {pvp: true, keepInventory: true, doMobSpawning: false, showCoordinates: true}).

spawn_entitiesC

Summon entities (npc, armor_stand, villager_v2, zombie, ...) with optional name tags and tags. Tags make it easy to target them later from commands and functions.

fill_containerC

Put items into a chest, barrel, shulker box or other container block: loot rooms, kit chests, rewards.

set_signB

Write text on a sign block (place the sign first). Use \n for new lines.

map_functionsB

Write game logic as .mcfunction files into a behavior pack inside the managed world (Bedrock's replacement for command block chains). Functions are called with /function ; names listed in tick run every tick. The server reloads them right away. Example: {"teams/tp_red": ["tp @a[tag=red] 10 65 0"]}.

region_statsA

Count what's in a region of the world: block totals, the most used blocks and their share. Good for checking a palette or estimating materials.

viewA

Render a picture. source=last shows the last generated or imported build without touching the world; source=world reads a region. mode: iso (isometric 3D, view 0-3 picks the corner), top (top down), slice (vertical cut at slice_at along slice_axis), heightmap (terrain colours for big areas, cheap). Markers from the project can be drawn on top.

find_blocksB

Find where certain blocks are inside a region (e.g. all chests, all diamond_ore, stray barrier blocks). Returns positions, capped by limit.

list_entitiesC

Entities in a region (or everywhere loaded): type, id, name tag, position and tags.

check_mapA

Playability checks on a region: floating block groups, whether spawn points are safe (floor, headroom, no hazards), whether points can be reached on foot from a start (walk, step up, drop, sprint jumps), symmetry score for competitive maps, and dark spots where hostile mobs could spawn. Uses project markers as spawns when none are given.

markersB

Markers saved from earlier builds in this project (spawns, doors, chests, checkpoints, portals...), grouped by the op that made them.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

B3.2/5.0

Scored across 51 tools

Disambiguation4/5

Despite 51 tools, most target distinct resource+action pairs (world_*, server_*, plan_*, project_*, region/block editing, analysis). A few pairs need the descriptions to separate: server_console vs run_commands, ws_listen/ws_status/use_connection vs server_status, and generate vs fill_region/place_blocks. The descriptions do explicitly disambiguate these (e.g. 'In-game commands are better sent with run_commands'), so overlap is manageable but present.

Naming Consistency3/5

Everything is snake_case, which helps, but the verb/noun ordering is mixed: block_search, world_list, server_start (noun_verb) alongside find_blocks, list_entities, check_map, use_connection (verb_noun), plus bare names like generate, view, markers. Readable but not a predictable pattern.

Tool Count2/5

51 tools is very heavy for a single server; even granting the breadth of Minecraft map building (server, world, project, plan, generation, editing, analysis, rendering), the surface is large enough that an agent must scan many names to find the right one. Some consolidation (e.g. merging plan_* or ws_* helpers) would be reasonable.

Completeness4/5

Coverage is unusually thorough: server lifecycle, world create/import/export/backup/restore, project memory, plans, generators, block edits, structures, palette, commands, entities, functions, and analysis/rendering. Minor gaps exist (no world_delete or project delete/close, region deletion only via region_mark with name), but nothing that blocks core workflows.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues