MCP server

Connect an AI agent (Claude, Cursor or any client that speaks the Model Context Protocol) and it can build a pack for you: create it, generate Blocks, 3D Models, Items, GUIs, Dialogs, Icons and Sounds, bring in files you already have, look at what came back, and try again where it's wrong.

It is the same API as the rest of this reference, with the same AI Credits, and it needs a key of its own. The difference is that the agent gets a list of tools to call instead of URLs somebody has to program against.

Connect#

The server lives at https://api.resourcepack.ai/mcp and authenticates with an MCP key from the Developers page. MCP keys start rpai_mcp_ and only work on the MCP server, and API keys only work on the REST API, so revoking the key you gave an agent never breaks your own code. The wrong kind of key is refused with wrong_key_kind. (Keys made before MCP keys existed work in both places.)

1. 1

   Get an MCP key

   studio.resourcepack.ai/developers, the MCP keys card. Copy it straight away: it is only shown once.

2. 2

   Add the server to your client

   In Claude Code:

   claude mcp add --transport http resourcepack-ai \
     https://api.resourcepack.ai/mcp \
     --header "Authorization: Bearer rpai_mcp_YOUR_KEY"

   Any client that takes a JSON config wants this:

   {
     "mcpServers": {
       "resourcepack-ai": {
         "type": "http",
         "url": "https://api.resourcepack.ai/mcp",
         "headers": { "Authorization": "Bearer rpai_mcp_YOUR_KEY" }
       }
     }
   }

3. 3

   Ask for something

   "Make me a pack of overgrown temple blocks: mossy bricks, cracked stone and a carved idol model." The agent will create the pack, generate into it, wait for the results and show you what it made.

What the agent gets#

One tool per endpoint in this reference, named after it, plus one that has no HTTP equivalent. Each name below links to the endpoint it calls, where the arguments are documented in full.

The tools are generated from the same source as this reference and the OpenAPI document, so they take the same arguments, limits and enums. An endpoint that is switched off is left out of the list.

wait_for_job waits, so the agent doesn't poll#

Every generation is asynchronous: you get a job handle and poll it. For an agent, each poll costs a whole turn, so wait_for_job does the waiting on the server instead. The agent passes every handle it is waiting on in one call and gets one answer when they have all finished.

It waits 120 seconds by default, up to 600 with timeoutSeconds. If time runs out it says which jobs are still going and the agent calls again. Nothing is lost or charged twice.

Files come back as files#

get_asset_file returns a generated texture, sprite or icon as an image, so the agent can actually look at what it made before telling you it is done, and regenerate it if it is wrong. Sounds come back as audio, models as their JSON.

Changing what's there, and what it costs#

There are three ways to change an asset, and only one is free:

Dialogs have no hand-edit tool. A Dialog can't be uploaded or written as JSON, so an agent changes one only through edit_asset, addressed as texture/gui:<id>. This works on Dialogs in Minecraft's own look (Dialog style):

• mode: "edit" changes one page from a sentence ("add a Close button", "reword the title").
• mode: "restyle" gives one page a new look with nothing moved or reworded.
• page picks the page (the first by default).

Each call is one page and costs a flat 15 AI Credits, finished when it answers. regenerate_asset makes a whole new Dialog at the price of generating one. restore_asset_version puts back an earlier version for free. To move pieces, change a button's command or fix a word without spending credits, open the Dialog in Studio's editor.

Sending files in#

upload_asset, upload_reference and import_pack take a file in one of four forms:

• text: the file as text, such as a model's JSON the agent wrote itself.
• base64: the bytes inline. Fine for a 16px texture.
• url: a public https address to fetch it from.
• upload: the id from create_upload, after the bytes were PUT to the URL it returned.

Use upload for any file on disk. An agent with a shell sends the bytes itself, so they never pass through the model:

curl -T lantern.bbmodel "<url from create_upload>"

Base64 works too, but an agent writes it a token at a time, so it is slow and expensive for anything bigger than a small image.

An import runs after import_pack answers, like a generation: the agent waits on its job (<pack>:import) with wait_for_job, and get_job then has the full report of what came in and what was left out.

export_pack confirms the export built and how big it is, but doesn't return the file, which is megabytes an agent has no use for. Download it over HTTP with an API key (an MCP key is refused there):

curl -H "Authorization: Bearer $RPAI_KEY" -o pack.zip \
  https://api.resourcepack.ai/v1/packs/YOUR_PACK/export

Limits and behaviour#