Blueprint MCP turns a prompt into an architecture diagram PNG

A diagram generator, not a code analyser

The README describes the project in one line: diagram generation for understanding codebases and system architecture using Nano Banana Pro. That wording sets the boundary. Blueprint MCP does not parse your repository, build a dependency graph or prove anything about your code. It receives a prompt, hands it to an image generation model, and gives you a picture back.

What it does do is give an agent a new output channel. The README positions it inside Arcade's ecosystem, where it combines with HubSpot, Google Drive, GitHub and other Arcade tools to extract data from your systems and visualize it as diagrams. So the diagram content comes from whatever the agent can reach: files in the working tree, a document in Drive, a deal record in HubSpot. The server is named `architect_mcp`, which is the name you add to an Arcade gateway, and the repository itself is small, with `.gitignore`, `README.md`, `images/` and `src/` at the top level.

The practical read: this is a thin tool around an image model, and the quality of what you get depends almost entirely on the prompt you feed it.

Setup goes through the Arcade CLI from sign-up to gateway

Installation is a sequence of account and CLI steps rather than a single install command. The first step is signing up for Arcade at https://arcade.dev, then creating a Python virtual environment:

# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

The Arcade CLI itself is installed with pip:

pip install arcade-mcp

Then you authenticate:

arcade-mcp login

The image generation side needs a Google AI Studio API key, which the README points you to obtain at https://aistudio.google.com. That key is stored in Arcade rather than in a local environment file:

arcade-mcp secret set GOOGLE_API_KEY="your_api_key_here"

Deployment follows the same pattern. You clone the repository and run the deploy command from inside it:

cd blueprint-mcp
arcade-mcp deploy

The last two steps are configuration rather than code. In the dashboard at https://api.arcade.dev/dashboard you create a Gateway and add the deployed `architect_mcp` server to it. In Cursor you open Settings, go to MCP, add your Arcade gateway URL and restart the editor. Only after that restart does the agent see the three tools.

Three tools and a fixed 30 second generation window

The tool surface is three calls. `start_diagram_job` starts generation and returns a job ID. `check_job_status` tells you whether the job is complete. `download_diagram` returns the PNG as base64. The README lays out the flow:

1. `start_diagram_job` returns a job ID instantly 2. Wait 30 seconds, while Nano Banana Pro generates 3. `check_job_status` checks if the result is "Complete" 4. `download_diagram` gets the base64 PNG 5. The agent decodes it and saves it to the workspace

The asynchronous shape is what an image model forces on you. The job ID plus a poll call means the agent has to wait and retry rather than block on a single request, and the 30 second figure in the README is a stated expectation rather than a guarantee. A job that takes longer simply needs another `check_job_status` call.

Note what happens to the bytes. The server returns base64, and the final artifact on disk is whatever the agent decides to write after decoding. That puts the saving step in the agent's hands, which is convenient inside Cursor and one more thing to check if you use the server from another client.

The prompt carries the diagram spec, including the art style

The README's example prompts show what a good request looks like. A codebase request points at a directory and asks for components and their relationships:

Analyze the authentication module in src/auth/ and create an 
architecture diagram showing the components and their relationships.

Others ask for a sequence diagram of an OAuth flow from a specific file, a flowchart of payment processing from checkout to confirmation, or a data flow diagram for an ETL pipeline based on the `data/` directory. Two more combine Arcade tools: pulling the latest HubSpot deal for a company and drawing the proposed solution, or reading a system design doc from Google Drive and generating a visual from it.

The examples in the README go further and show the prompt the tool actually received, and these are the most instructive part of the documentation. The banking example asks for a diagram with five explicit layers, from end users through the AI layer, the Arcade MCP Runtime box with its components, and the bank's existing infrastructure, with labelled arrows and a fixed visual treatment: technical whiteboard style, muted colors, monospace fonts, 16:9. The LangGraph example specifies six labelled sections and asks for printable quality.

Read that as documentation of how to prompt. The image model follows detailed instructions, and the style directives are part of the request, not part of the server.

Your codebase reaches the model through the agent, not the server

One detail in the examples is worth isolating, because it determines what actually gets drawn. The LangGraph prompt includes a local path, `/Users/guru/dev/nano/langgraph`, and asks for a thorough analysis of the checked out codebase. The server has no knowledge of that directory. What happens is that the agent, running inside Cursor with access to the working tree, reads the code and passes the substance of it into the diagram prompt.

That division has a practical up side and a practical down side. The up side is that the diagram reflects what the agent could actually read, and the agent can be asked to check out a repository first. The down side is that the server cannot verify anything. A prompt that overstates what the code does produces a confident picture of the wrong architecture, and nothing in the workflow checks the image against the source.

The README does describe the server as combining with GitHub and other Arcade tools to extract data from systems, which is the same mechanism pointed at remote sources instead of local files. Either way the diagram is a rendering of a prompt, not a rendering of the code.

The cost is an account, a gateway, a key and a fixed wait

Every image request carries the same overhead. The request goes through the Arcade gateway, the gateway forwards to the deployed `architect_mcp` server, the server calls the image model with your Google AI Studio key, and the result comes back as base64 after the generation window. None of that is under your control once the flow is running, and the README gives you no timeout, retry or cancellation behaviour to plan around.

There are also limits in the repository itself. It has no GitHub releases, so there is no version to pin from a release list, and the top level contains no licence file, which means the terms for using the code, and by extension for what you do with its output, are not stated in the repository. The last push was on 2026-07-22.

For a one-off architecture sketch in a team that already uses Arcade and Cursor, those costs are tolerable. For a pipeline that needs diagrams as part of a repeatable process, the account and gateway dependencies and the absence of a stated licence are reasons to look further.

The alternative approach is worth naming plainly. An agent can describe an architecture in text in the conversation, or write a diagram in a text notation that you can commit, diff and search. The image route wins on presentation and on speed for a human audience; the text route wins on reviewability, and the repository offers no versioning or history of its own either way.

Editorial conclusion

Adopt Blueprint MCP when you want a printable visual of an architecture in minutes, when your team already lives in Arcade and Cursor, and when an image is an acceptable output format. Do not adopt it as a source of truth for diagrams, since the result is a PNG produced by an image model and the repository ships no licence file, so check the terms before using the output commercially. Verify first that `arcade-mcp login`, `arcade-mcp secret set GOOGLE_API_KEY` and `arcade-mcp deploy` succeed on your machine, that your gateway at api.arcade.dev carries the `architect_mcp` server, and that the version you copy from the repository, last pushed on 2026-07-22, is the one your agent talks to.

Frequently asked questions

Official sources

1. ArcadeAI/blueprint-mcp on GitHub
2. Issues
3. README