Skip to main content
Glama
██╗   ██╗██╗███╗   ██╗███████╗ ██████╗██████╗  █████╗ ███████╗████████╗
██║   ██║██║████╗  ██║██╔════╝██╔════╝██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
██╔████╔╝██║██╔██╗ ██║█████╗  ██║     ██████╔╝███████║█████╗     ██║
╚██╔╝██╔╝██║██║╚██╗██║██╔══╝  ██║     ██╔══██╗██╔══██║██╔══╝     ██║
 ╚═╝ ╚═╝ ██║██║ ╚████║███████╗╚██████╗██║  ██║██║  ██║██║        ██║
         ╚═╝╚═╝  ╚═══╝╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝        ╚═╝
            M   C   P       S   E   R   V   E   R

🟫🟩🟫 Give any AI agent a body inside Minecraft. 🟫🟩🟫

Connect · Build · Mine · Fight · Farm · Trade · Chat — one MCP server, any AI, any world.

MIT License Node.js >=18 MCP TypeScript


⛏️ What is this?

minecraft-mcp-server is a Model Context Protocol server that puts an AI agent inside a real Minecraft Java Edition world through mineflayer. It exposes 61 tools covering movement, building, mining, combat, farming, inventory, villager trading, and world perception — so any MCP-compatible client can spawn a bot that actually sees the world, walks around it, and acts on it.

This is not tied to any single AI product. It speaks plain MCP over stdio, so it works with any MCP host — Claude Desktop, Claude Code, Cursor, Cline, Windsurf, your own custom MCP client, or anything else that can launch a local MCP server. If your agent can talk MCP, it can play Minecraft.

Built for singleplayer worlds opened via "Open to LAN", offline-mode/cracked servers (e.g. TLauncher), and standard online-mode servers.


Related MCP server: Renge Bot

🧰 Tool chest — what your agent can do

Category

Tools

🔌 Connection

connect, disconnect, status

👀 Perception

position, nearby blocks, block lookup, find block, nearby entities, inventory

🚶 Movement

goto position, goto player, follow player, look at, look direction, stop, jump

🧱 Building

place block, dig block, build cuboid structure, clear area

🖐️ Interaction

chat, equip item, toss item, craft item, attack entity, activate block, eat, sleep, collect block (mine + auto-pickup)

🎒 Inventory

open/deposit/withdraw/close container, use furnace, give item (creative), move item slot

⚔️ Combat

sprint, sneak, use held item (block/draw/drink), shoot bow

🌾 Farming

till soil, plant seed, harvest crop

🌍 World

biome lookup, light level, get time, read sign

🗣️ Social

whisper, list players, open villager trades, execute trade

🧭 Misc

mount, dismount, respawn, wait

Every tool returns structured JSON and actionable error messages — no raw stack traces dumped on your agent.


📦 Installation

git clone https://github.com/AhmadTariq1337/minecraft-mcp-server.git
cd minecraft-mcp-server
npm install
npm run build

This compiles TypeScript from src/ into dist/, producing dist/index.js — the entry point your MCP host will launch.


🔧 Configuring your MCP client

Any host that supports local (stdio) MCP servers can use this. The server is launched as:

node /path/to/minecraft-mcp-server/dist/index.js

Claude Desktop / Claude Code

Add to your MCP config (claude_desktop_config.json or equivalent):

{
  "mcpServers": {
    "minecraft": {
      "command": "node",
      "args": ["/absolute/path/to/minecraft-mcp-server/dist/index.js"]
    }
  }
}

Cursor / Cline / Windsurf / other MCP hosts

The pattern is the same everywhere — point your client's MCP server config at node + the absolute path to dist/index.js. Consult your client's docs for where that config file lives.

🔑 No API keys, no cloud dependency. Everything runs locally over stdio.


🎮 Quick start in-game

  1. Open your Minecraft world (singleplayer works great).

  2. Press Escape → Open to LAN — note the port number shown in chat.

  3. Ask your agent to connect:

    "Connect to localhost on port <port> as <bot-name>, auth offline."

  4. That's it — your agent can now see the world, move, mine, build, and chat.

{
  "host": "localhost",
  "port": 12345,
  "username": "AgentBot",
  "auth": "offline"
}

Use auth: "microsoft" only if connecting with a real Mojang/Microsoft account to an online-mode server.


🧱 Supported Minecraft versions

This server rides on mineflayer, which determines actual protocol support. At time of writing, the published mineflayer release supports up through Minecraft 1.21.x. Mojang's 2026 year.drop versioning scheme (e.g. 26.1.x) is not yet supported upstream — connecting to a newer world will fail with a protocol/version mismatch until mineflayer ships support. Older clients like OptiFine 1.21.11 or vanilla 1.21.x work out of the box.

If you hit a version-mismatch error, launch a world on a supported version (TLauncher makes this easy) while upstream support catches up.


🏗️ Project layout

minecraft-mcp-server/
├── src/
│   ├── index.ts           entry point — registers every tool group
│   ├── bot.ts              mineflayer connection lifecycle
│   ├── types.ts             shared types
│   ├── constants.ts        tunable limits (scan radius, timeouts, etc.)
│   └── tools/
│       ├── connection.ts
│       ├── perception.ts
│       ├── movement.ts
│       ├── building.ts
│       ├── interaction.ts
│       ├── inventory.ts
│       ├── combat.ts
│       ├── farming.ts
│       ├── world.ts
│       ├── social.ts
│       └── misc.ts
└── dist/                    compiled output (npm run build)

🤝 Contributing

Issues and PRs welcome — especially around mineflayer version-support tracking, new tool coverage, and better pathfinding heuristics. Keep tool descriptions actionable (what it does, what it returns, common error cases) so any agent — not just one AI vendor's — can use them well without guesswork.


📜 License

MIT — see LICENSE.

🟩🟫🟩🟫🟩 Built block by block. 🟩🟫🟩🟫🟩

Available Tools

55 tools
minecraft_activate_blockUse / Activate BlockB

Right-clicks a block at the given coordinates — opens chests/doors/trapdoors/furnaces, presses buttons, pulls levers, opens the crafting-table UI, etc. Walks within reach first.

Returns: { message: string, block: string } Errors: no block there, or unreachable.

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

minecraft_attack_entityAttack EntityA
Destructive

Attacks a specific entity by id (from minecraft_get_nearby_entities), or the nearest hostile mob if no id is given. Swings the bot's currently equipped weapon once — call repeatedly for multiple hits.

Returns: { message: string, target: string } Errors: entity not found / out of reach, or no hostile mobs nearby (when entity_id omitted).

Inputs: entity_id.

minecraft_build_structureBuild Cuboid StructureA

Fills a cuboid region between two corner coordinates with a block from inventory — for walls, floors, platforms, boxes. Builds bottom-up so each block has something to rest against.

Args:

  • hollow (boolean): if true, only builds the outer shell (walls/floor/ceiling) instead of a solid block. Good for rooms.

  • Region is capped at 500 blocks total; oversized requests are truncated.

Returns: { placed, skipped, failed, message }. Blocks that already match are skipped; blocks with no solid neighbor available yet are reported as failed rather than aborting the whole build.

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

minecraft_chatSend Chat MessageA

Sends a message in in-game chat, visible to all players on the server. Also works for chat commands if the message starts with '/' and the bot has permission.

Inputs: message (required).

minecraft_clear_areaClear / Dig Out AreaA
Destructive

Digs out (breaks) every non-air, diggable block in a cuboid region between two corners — for clearing land or hollowing out a room. Digs top-down.

Region is capped at 500 blocks total.

Returns: { dug: number, skipped: number, message: string }

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more.

minecraft_close_containerClose Container / UIA
Idempotent

Closes whatever container, furnace, or villager-trade UI is currently open. Safe to call even if nothing is open.

Inputs: no named parameters.

minecraft_collect_blockCollect Blocks (Mine + Pick Up)A
Destructive

Finds the nearest matching block(s), mines them, and automatically walks over to pick up the drops — more convenient than minecraft_dig_block when you actually want the item in inventory (e.g. "get me some wood").

Returns: { message: string, requested: number } Errors: no matching blocks within range, or a dig/pickup failure partway through.

Inputs: block_name (required), count.

minecraft_connectConnect to Minecraft WorldA

Connects the bot to a running Minecraft Java Edition world (server, LAN world, or local server jar).

For TLauncher: TLauncher accounts are typically NOT Microsoft-authenticated, so use auth="offline" (this is also correct for cracked/offline-mode servers and singleplayer worlds opened via "Open to LAN"). Use auth="microsoft" only for a real Mojang/Microsoft account joining an online-mode server.

To connect to your own singleplayer world: open the world in Minecraft, press Escape -> "Open to LAN", note the port shown in chat, then call this tool with host="localhost" (or "127.0.0.1") and that port.

Must be called before any other minecraft_* tool.

Returns: { message: string } confirming connection and spawn position. Errors: connection refused, wrong port, version mismatch, or auth-mode mismatch (offline bot hitting an online-mode server, or vice versa).

Inputs: host (required), username (required), auth, port, +1 more.

minecraft_container_depositDeposit Item Into ContainerA

Moves an item from the bot's inventory into the currently open container. Call minecraft_open_container first.

Returns: { message } Errors: no container open, or item not carried.

Inputs: item_name (required), count.

minecraft_container_withdrawWithdraw Item From ContainerA

Moves an item from the currently open container into the bot's inventory. Call minecraft_open_container first.

Returns: { message } Errors: no container open, or item not present in the container.

Inputs: item_name (required), count.

minecraft_craft_itemCraft ItemA

Crafts an item using a recipe the bot currently has ingredients for. If the recipe needs a 3x3 grid, pass use_crafting_table=true and make sure a crafting table is within a few blocks (minecraft_find_block "crafting_table", or minecraft_place_block one first).

Returns: { message: string, crafted: string, count: number } Errors: unknown item, no known recipe fits current inventory, or no crafting table in reach when one is required.

Inputs: item_name (required), count, use_crafting_table.

minecraft_dig_blockDig / Break BlockA
Destructive

Mines/breaks the block at the given coordinates. Automatically walks within reach first. Drops fall to the ground — use minecraft_collect_block instead if you also want the bot to auto-pick-up the drops.

Returns: { message: string, block: string } Errors: block not diggable (e.g. bedrock, air), unreachable, or missing required tool.

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

minecraft_disconnectDisconnect from Minecraft WorldA
Idempotent

Cleanly disconnects the bot from the current world/server. Safe to call even if not connected.

Inputs: no named parameters.

minecraft_dismountDismountA
Idempotent

Dismounts whatever entity/vehicle the bot is currently riding. Safe to call even if not mounted.

Inputs: no named parameters.

minecraft_eatEat FoodA

Equips a food item from inventory and eats it to restore hunger.

Returns: { message: string } Errors: item not found, item isn't food, or the bot can't eat right now (food already full).

Inputs: item_name (required).

minecraft_equip_itemEquip / Hold ItemA
Idempotent

Equips an item from inventory to the bot's hand or an armor slot.

Returns: { message: string } Errors: item not found in inventory.

Inputs: item_name (required), destination.

minecraft_find_blockFind Nearest BlockA
Read-onlyIdempotent

Searches outward from the bot for the nearest block(s) matching a given block name — useful for "find me some water" / "find diamond ore" before navigating or mining.

Returns: { found: boolean, count: number, blocks: [{ x, y, z, name, distance }] }

Inputs: block_name (required), count, max_distance.

minecraft_follow_playerFollow / Stop Following PlayerA

Starts (or stops) continuously following a named player at a set distance. Unlike minecraft_goto_player this does NOT block — the bot keeps following in the background until minecraft_stop is called or this tool is called again with stop=true.

Returns: { message: string }

Inputs: username (required), stop, range.

minecraft_get_biome_atGet Biome At CoordinatesA
Read-onlyIdempotent

Looks up the biome at exact world coordinates.

Returns: { x, y, z, biome: string | null }

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

minecraft_get_block_atInspect Block At CoordinatesA
Read-onlyIdempotent

Looks up a single block at exact world coordinates.

Returns: { x, y, z, name, hardness: number | null, diggable: boolean } or an error if the chunk isn't loaded.

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

minecraft_get_inventoryView Bot InventoryA
Read-onlyIdempotent

Returns everything the bot is carrying: hotbar/inventory items, currently held item, and worn armor.

Returns: { items: [{ slot, name, count, displayName }], heldItem: string | null, armor: { head, torso, legs, feet } (each string | null) }

Inputs: no named parameters.

minecraft_get_light_atGet Light Level At CoordinatesA
Read-onlyIdempotent

Returns light levels at a block — useful for checking if an area is safe from mob spawns (block light < 8 with sky light 0 at night is generally spawnable).

Returns: { x, y, z, light: number (0-15, total), skyLight: number (0-15) }

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

minecraft_get_nearby_blocksView Nearby BlocksA
Read-onlyIdempotent

Scans the world around the bot and lists non-air blocks it can see, closest first. This is the bot's "eyes" for terrain/structures — use it before building or navigating.

Args:

  • radius (number, 1-32): how far to scan, in blocks (default 8)

  • block_names (string[], optional): only return blocks matching these exact Minecraft block ids (e.g. ["oak_log", "stone", "chest"]). Omit to return all non-air blocks.

Returns: { count: number, blocks: [{ x, y, z, name }] } capped at 400 results.

Inputs: radius, block_names.

minecraft_get_nearby_entitiesView Nearby EntitiesA
Read-onlyIdempotent

Lists players, mobs, and other entities near the bot, closest first — the bot's awareness of who/what is around it.

Args:

  • radius (number, 1-64): search radius in blocks (default 16)

  • type_filter (string, optional): one of "player", "hostile", "mob" (non-hostile mobs/animals), "all" (default "all")

Returns: { count: number, entities: [{ id, type, name, username?, x, y, z, distance }] }

Inputs: radius, type_filter.

minecraft_get_positionGet Bot PositionA
Read-onlyIdempotent

Returns the bot's exact current coordinates, facing direction, and which block it's standing on/in.

Returns: { x, y, z, yaw, pitch, standingOn: string, dimension: string }

Inputs: no named parameters.

minecraft_get_timeGet World TimeA
Read-onlyIdempotent

Returns the current in-game time and weather.

Returns: { timeOfDay: number (0-24000 ticks), day: number, isDay: boolean, moonPhase: number (0-7), isRaining: boolean }

Inputs: no named parameters.

minecraft_give_itemGive Item (Creative Mode)A

Spawns an item stack directly into the bot's inventory. Only works while the bot is in creative gamemode.

Returns: { message } Errors: bot not in creative mode, unknown item id, or inventory full.

Inputs: item_name (required), slot, count.

minecraft_goto_playerWalk To PlayerA

Paths the bot to stand near a named online player. Blocking call.

Returns: { message: string, position } on arrival. Errors: player not found/not loaded, or unreachable.

Inputs: username (required), range.

minecraft_goto_positionWalk To CoordinatesA

Paths the bot to a target position using pathfinding (navigates around obstacles, up stairs, across gaps it can jump). Blocking call — resolves once the bot arrives or pathfinding times out (60s).

Returns: { message: string, position: { x, y, z } } on arrival. Errors: unreachable destination, timeout, or no path found.

Inputs: x (required), y (required), z (required), range.

minecraft_harvest_cropHarvest CropA
Destructive

Breaks a fully-grown crop block at the given coordinates. For known crop types (wheat, carrots, potatoes, beetroots, nether_wart) this checks maturity first and refuses to harvest early unless force=true.

Returns: { message, block: string } Errors: nothing there, crop not fully grown (unless force=true), or not diggable.

Inputs: x (required), y (required), z (required), force.

minecraft_jumpJumpA

Makes the bot jump once in place.

Inputs: no named parameters.

minecraft_list_playersList Online PlayersA
Read-onlyIdempotent

Lists every player currently online, with ping and gamemode.

Returns: { count, players: [{ username, ping, gamemode }] }

Inputs: no named parameters.

minecraft_look_atLook At CoordinatesA
Idempotent

Turns the bot's head/body to face a specific point. Purely cosmetic/aiming — doesn't move the bot. Useful before minecraft_attack_entity or minecraft_activate_block for precision.

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

minecraft_look_directionLook In Compass DirectionA
Idempotent

Turns the bot to face a compass direction (north/south/east/west) or straight up/down. Purely cosmetic/aiming — does not move the bot.

Inputs: direction (required).

minecraft_mountMount EntityA

Mounts a rideable entity — boat, minecart, horse, donkey, mule, pig (with saddle), strider, or camel — by entity id (from minecraft_get_nearby_entities) or the nearest rideable one. Walks within reach first.

Returns: { message } Errors: no rideable entity found nearby.

Inputs: entity_id.

minecraft_move_item_slotMove Item Between Inventory SlotsA

Moves an item stack from one inventory slot to another, for organizing the hotbar/inventory. Slot map: 0 crafting output, 1-4 crafting grid, 5-8 armor, 9-35 main inventory, 36-44 hotbar, 45 off-hand.

Returns: { message }

Inputs: to_slot (required), from_slot (required).

minecraft_open_containerOpen ContainerA

Opens a chest, trapped chest, barrel, shulker box, dispenser, or dropper at the given coordinates and lists its contents. Walks within reach first. The container stays open until minecraft_close_container is called — minecraft_container_deposit/withdraw act on whatever is currently open.

Returns: { message, containerType: string, items: [{ slot, name, count }] } Errors: no container block there, or unreachable.

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

minecraft_open_villagerOpen Villager TradesA

Walks to and opens trade with a villager (by entity id from minecraft_get_nearby_entities, or the nearest one), and lists its available trades. Stays open until minecraft_close_container is called — use minecraft_trade to execute a trade.

Returns: { message, trades: [{ index, give: string[], receive: string, usesLeft, disabled }] } Errors: no villager nearby/found.

Inputs: entity_id.

minecraft_place_blockPlace BlockA

Places one block from the bot's inventory at the given world coordinates. Automatically walks within reach first and finds a solid neighboring block to place against. The target coordinates must currently be empty (air) and adjacent to at least one solid block — you can't place a block floating in mid-air.

Returns: { message: string } Errors: item not in inventory, no solid neighbor to place against, or unreachable.

Inputs: x (required), y (required), z (required), block_name (required).

minecraft_plant_seedPlant Seed / CropA

Plants a seed item on farmland at the given coordinates (till it first with minecraft_till_soil). Works for any plantable item: seeds, carrots, potatoes, beetroot_seeds, melon/pumpkin seeds, nether_wart (on soul sand).

Returns: { message } Errors: target block isn't farmland/soul sand, space above is occupied, or seed not in inventory.

Inputs: x (required), y (required), z (required), seed_item (required).

minecraft_read_signRead Sign TextA
Read-onlyIdempotent

Reads the text written on a sign at the given coordinates.

Returns: { x, y, z, front: string, back: string | null }

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

minecraft_respawnRespawn After DeathA
Idempotent

Respawns the bot at its spawn point/bed after dying. Only needed if the server's auto-respawn is disabled — check minecraft_status for health 0 first.

Inputs: no named parameters.

minecraft_set_sneakToggle SneakA
Idempotent

Turns sneaking (crouching) on or off — prevents falling off edges and hides the bot's nametag/hides it from some mobs.

Inputs: sneak (required).

minecraft_set_sprintToggle SprintA
Idempotent

Turns sprinting on or off. Sprint state persists across movement until toggled off or the bot stops.

Inputs: sprint (required).

minecraft_shoot_bowShoot BowA
Destructive

Equips a bow, optionally aims at a target point, draws it back for charge_ms, then fires. A full draw (~1000ms+) does full damage; shorter draws do less.

Returns: { message } Errors: no bow in inventory.

Inputs: target_x, target_y, target_z, charge_ms.

minecraft_sleepSleep in BedA

Finds the nearest bed (or one at given coordinates) and sleeps in it. Only works at night/during thunderstorms, and only if the bed is safe (no monsters nearby).

Returns: { message: string } Errors: no bed found nearby, not night, monsters nearby, or bed occupied/unsafe.

Inputs: x, y, z.

minecraft_statusGet Bot & World StatusA
Read-onlyIdempotent

Returns the bot's current health, hunger, position, gamemode, dimension, in-game time, weather, XP, and who else is online.

Returns: { connected: boolean, username: string, health: number (0-20), food: number (0-20), position: { x, y, z }, yaw: number, pitch: number, gameMode: string, dimension: string, isDay: boolean, isRaining: boolean, experienceLevel: number, heldItem: string | null, onlinePlayers: string[] }

Call minecraft_connect first if this returns connected: false.

Inputs: no named parameters.

minecraft_stopStop MovingA
Idempotent

Cancels any active pathfinding goal (goto/follow) and releases all movement keys. Use this to interrupt movement in progress.

Inputs: no named parameters.

minecraft_till_soilTill Soil Into FarmlandA

Equips a hoe and tills the dirt/grass block at the given coordinates into farmland, ready for planting. Walks within reach first.

Returns: { message } Errors: no hoe in inventory, block isn't tillable, or already farmland.

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

minecraft_toss_itemDrop ItemB
Destructive

Drops item(s) from inventory onto the ground in front of the bot.

Returns: { message: string }

Inputs: item_name (required), count.

minecraft_tradeExecute Villager TradeA

Executes a trade on the currently open villager (call minecraft_open_villager first) by trade index.

Returns: { message } Errors: no villager open, invalid trade index, trade disabled, or missing required items.

Inputs: trade_index (required), times.

minecraft_use_furnaceSmelt / Cook Item in FurnaceA

Opens a furnace (or blast furnace / smoker) at the given coordinates, loads input material and fuel from the bot's inventory, waits for smelting to progress, then collects whatever output is ready and closes the furnace. One call handles the whole loop.

Args:

  • input_item: material to smelt, e.g. "raw_iron", "raw_beef", "sand"

  • fuel_item: fuel to burn, e.g. "coal", "oak_planks". Omit if the furnace already has fuel loaded.

  • count: how many items to smelt (default 1)

  • wait_seconds: how long to wait before collecting output (default 12; vanilla smelting is ~10s/item with normal fuel). Call again to collect more once it's finished.

Returns: { message, collected: number, itemName: string | null } Errors: no furnace there, missing input/fuel in inventory, or unreachable.

Inputs: x (required), y (required), z (required), input_item (required), +3 more.

minecraft_use_held_itemStart / Stop Using Held ItemA

Starts or stops "using" the currently equipped item — this is the generic right-click-and-hold action: raising a shield to block, drawing back a bow/crossbow, drinking a potion, using a fishing rod, blocking with a sword (1.9+), etc. Pair with minecraft_shoot_bow for a ready-made bow-firing flow, or call this directly for shields/potions.

Returns: { message }

Inputs: action (required), offhand.

minecraft_waitWaitA
Read-onlyIdempotent

Pauses for a number of seconds — useful for letting things settle (smelting, mob spawning, water flowing) between other tool calls.

Inputs: seconds (required).

minecraft_whisperWhisper / Direct Message PlayerA

Sends a private message to a specific player, visible only to them (uses the server's /msg or /tell equivalent).

Returns: { message: string }

Inputs: message (required), username (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 55 tools

    Disambiguation4/5

    Most tools target distinct actions and resources. Some overlap exists (e.g., dig_block vs collect_block, activate_block vs open_container, get_position vs status), but the descriptions clarify the differences, preventing significant confusion for an agent.

    Naming Consistency4/5

    The vast majority of tools follow a verb_noun pattern (e.g., place_block, craft_item, get_position). A few bare verbs (chat, eat, sleep) and the reversed container_deposit/container_withdraw are minor deviations, but the overall style is consistent and predictable.

    Tool Count2/5

    At 55 tools, the server is over-scoped. While Minecraft is a complex domain, many tools could be consolidated (e.g., combining movement or inventory actions). The count is excessive and likely to overwhelm agents, making selection more difficult.

    Completeness5/5

    The tool set covers an extensive range of Minecraft interactions: connection, movement, world exploration, inventory management, building, farming, combat, trading, containers, furnaces, and player communication. It essentially provides complete lifecycle coverage for a bot, with only minor advanced features (e.g., enchanting) missing.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      Enables controlling a semi-autonomous Minecraft bot via MCP, supporting tasks like movement, combat, farming, and chatting.
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables controlling an autonomous Minecraft Java Edition player through MCP, with structured world perception, navigation, gathering, crafting, combat, building, skill-based task execution, and long-term memory integration.
      -
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables LLMs to control a Minecraft bot and interact with the game through MCP tools, including observing state, moving, mining, crafting, building, farming, managing inventory, enchanting, and chatting in-game.
      1
      -