Which integrations are available for this server?

Allows exporting the Lego build to a Blender Python script for 3D rendering. Allows models running on Ollama to build physically valid Lego structures through an MCP host.

How do I use lego-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@lego-mcp create a new build called 'house' on a 32x32 baseplate" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

lego-mcp

by Axel-Jalonen

Overview Schema Source Related Servers Score Discussions Admin

Python

Local

lego-mcp

An MCP server where a model can only build physically valid Lego. Instead of letting the model free-form geometry (and hallucinate impossible structures), every action goes through a constraint engine that behaves like real plastic:

Catalog-only parts — brick_2x4, plate_1x6, tile_2x2, slopes (slope_2x2, slope_inv_1x2, …), baseplates (baseplate_32x32, …). Unknown part names are rejected with suggestions. No hallucinated 3×5 bricks.
Solid bricks — placements that overlap existing pieces are rejected, with the exact colliding cells and the lowest free z reported back.
Stud-to-tube connection required — a piece must sit on studs of an existing piece, on the baseplate, or press its own studs up under an overhang. Floating bricks are rejected with a valid z suggested.
Tiles are smooth — nothing can stack on a tile.
Slopes are directional — studs only on their non-sloped rows (nothing attaches to the sloped face); rotation is 0/90/180/270 and slopes descend toward +y at rotation 0. Inverted slopes grip below only on their tall rows.
Baseplates are ground-only — studs on top, smooth underneath, z=0 only.
No orphaning — removing a piece that would leave others disconnected from the baseplate is refused ("remove those first, top down").
Stability hints — extreme cantilevers succeed but return a warning.

The error messages are written for the model: each rejection explains the violated constraint and suggests a fix, so an agent converges on buildable structures instead of drifting.

Built by a model, through the constraints

Every piece below was placed by an LLM whose only tools were this server's — each brick validated stud-by-stud, then exported to Blender and rendered. No piece floats, overlaps, or stacks on a tile.

A small Lego village — houses, roads, and trees on a baseplate

Corbelled arch	Colonnade

The corbelled arch is the constraint engine at its most demanding: every course steps inward off the studs of the one below, and the two flanks have to meet at the crown without a single floating brick — the model gets there because each illegal step is bounced back with the reason and a legal alternative.

Related MCP server: mcp-toolbox

Coordinates

x, y in studs, z in plates (1 brick = 3 plates tall).
z=0 is the baseplate; a brick on top of a brick placed at z=0 goes at z=3.
rotation is 0 or 90 (swaps the footprint).

Tools

Tool	Purpose
`new_build(name, width, depth)`	fresh baseplate
`list_parts()`	full catalog + colors
`place_brick(part, x, y, z, rotation, color)`	validated placement
`remove_brick(piece_id)`	validated removal
`get_build()`	full state as JSON
`view_layers(z_from, z_to)`	top-down ASCII map per plate layer
`load_build(name)`	reload a saved build (re-validated on load)
`export_build(fmt)`	`ldraw` → `.ldr` (BrickLink Studio / LeoCAD), `blender` → `bpy` script

State auto-saves to <state>/<name>.json after every mutation and the latest build is resumed on server restart. The state directory is, in order: $LEGO_MCP_HOME/builds if set, else the repo's builds/ when run from a writable checkout, else ~/.lego-mcp/builds when installed. Set LEGO_MCP_HOME to keep builds wherever you like.

Install

lego-mcp is a standard stdio MCP server, so any MCP-capable host can run it. It's packaged as a normal Python distribution — the only thing a host needs is a command that launches it.

Run it with no install (recommended)

uvx fetches and runs it in a throwaway environment, so there's nothing to maintain:

uvx --from "git+https://github.com/Axel-Jalonen/lego-mcp" lego-mcp   # straight from this repo
uvx --from ./dist/lego_mcp-0.1.0-py3-none-any.whl lego-mcp           # from a built wheel

Or install it as a tool

pipx install "git+https://github.com/Axel-Jalonen/lego-mcp"   # or: pip install ...
lego-mcp                     # the `lego-mcp` command is now on PATH

Or grab the prebuilt wheel from the latest release and pipx install lego_mcp-0.1.0-py3-none-any.whl.

Build the distributable yourself

uv build          # -> dist/lego_mcp-0.1.0-py3-none-any.whl  (+ .tar.gz)

The .whl is the portable artifact: copy it anywhere, uvx --from <the.whl> lego-mcp, done. No source checkout, venv, or absolute paths needed.

Wiring it into a host

Every MCP host takes the same shape — a command + args. Use uvx so the host doesn't need Python set up:

{
  "mcpServers": {
    "lego": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/Axel-Jalonen/lego-mcp", "lego-mcp"],
      "env": { "LEGO_MCP_HOME": "~/lego-builds" }
    }
  }
}

Claude Desktop → claude_desktop_config.json (Settings → Developer).
Claude Code → claude mcp add lego -- uvx --from git+https://github.com/Axel-Jalonen/lego-mcp lego-mcp (this repo also ships a dev .mcp.json).
Cursor / Windsurf / VS Code MCP → the same mcpServers block.
Ollama → Ollama's own runtime doesn't load MCP servers directly; run it through an MCP host that talks to Ollama, e.g. mcphost or Open WebUI. mcphost reads the identical config above, so pointing it at the same uvx command gives your local model the eight Lego tools.

Development

python3 -m venv .venv
.venv/bin/pip install -e . pytest          # editable install
.venv/bin/python -m pytest tests/          # 15 constraint tests

Pointing a small model at it

agent/build_agent.py runs an agent loop where a model's only tools are this server's — no filesystem, no bash, no repo access. The constraint engine rejects every invalid move with a corrective hint, so even a small model can only ever produce physically valid builds:

export ANTHROPIC_API_KEY=sk-ant-...
.venv/bin/python agent/build_agent.py "build a small watchtower"
.venv/bin/python agent/build_agent.py --model claude-sonnet-5 "build a bridge"

Defaults to claude-haiku-4-5. The final state is reported by the engine (get_build), not by the model's own claims, and builds land in builds/.

Layout

lego_mcp/catalog.py — part definitions (footprint, height in plates, stud availability, LDraw ids) and colors
lego_mcp/engine.py — occupancy grid, connection rules, orphan detection, ASCII views, save/load
lego_mcp/export.py — LDraw + Blender exporters
lego_mcp/server.py — FastMCP tool layer

Available Tools

8 tools

export_buildA

Export the build. fmt='ldraw' writes builds/.ldr (openable in BrickLink Studio / LeoCAD); fmt='blender' writes builds/_blender.py, a bpy script that constructs the model in Blender.

ParametersJSON Schema

Name	Required	Description	Default
`fmt`	No		ldraw

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It explains the output behavior for each format (file names, scripts) but does not mention potential side effects like file overwriting or required permissions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise (two sentences), front-loaded with the main action, and every sentence adds meaningful detail without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one optional parameter) and presence of an output schema, the description adequately covers the output details but lacks mention of error conditions or file overwrite behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, but the description fully compensates by explaining the two possible values for 'fmt' and their exact effects, adding significant meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose ('Export the build') and specifies the output formats and file names, making it distinct from siblings like get_build or list_parts.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for exporting but does not provide explicit when-to-use or when-not-to-use guidance, nor does it distinguish from alternative export methods.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_buildA

Current build state: piece list with positions, inventory, dimensions.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Although no annotations are provided, the description clearly indicates this is a read-only operation (returns current state). It is non-destructive and safe. However, it does not explicitly state that it performs no side effects or that it requires specific permissions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that directly conveys the tool's purpose and output without extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which presumably details the structure), the description provides a sufficient high-level summary. It lists the three main components (piece list with positions, inventory, dimensions), which is adequate for a query tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema coverage is 100%. The description adds no parameter-level information, which is acceptable as there are none to document.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool returns the current build state including piece list, positions, inventory, and dimensions. It implies a read operation but lacks a verb like 'retrieve' or 'get'. It is distinguishable from siblings like 'export_build' (export) and 'place_brick' (mutation).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives (e.g., 'view_layers' for layers, 'list_parts' for just parts). There is no mention of prerequisites or context for use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_partsA

List every part in the catalog (the ONLY placeable pieces) and all colors. Sizes are studs; height is in plates (brick=3, plate/tile=1). Tiles have smooth tops. Slopes have studs only on their non-sloped rows (at rotation 0 the slope descends toward +y; rotate 90/180/270 to face it). Baseplates have studs on top, nothing underneath, and only go at z=0.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully reveals behavior: it lists all parts and colors, and provides detailed attributes (sizes in studs, height in plates, tile/slope/baseplate specifics). No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is relatively concise but packs many details into a dense paragraph. It is front-loaded but could be broken into clearer sections for readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no parameters and an output schema exists, the description provides rich context (only placeable pieces, z=0 constraint for baseplates) that is essential for correct tool usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so baseline is 4. The description adds meaning beyond the schema by explaining the meaning of sizes, colors, and part-specific details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists every part and color in the catalog, with a specific verb 'list' and resource 'parts in catalog'. It distinguishes itself from sibling tools that deal with builds.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implicitly indicates when to use this tool (to get part info before placing), but does not explicitly state when not to use it or provide alternative tools. The context of sibling tools being build-related helps, but lacks explicit guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

load_buildA

Load a previously saved build by name (see saved .json files in builds/). The save is re-validated piece by piece on load.

ParametersJSON Schema

Name	Required	Description	Default
`name`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that the save is re-validated piece by piece on load, which is a key behavioral trait. However, it does not explicitly state if the tool is read-only or has side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no wasted words. First sentence states the purpose, second adds behavioral detail. Perfectly front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists and sibling tools provide context, the description is complete: it tells what, where, and a key behavior (re-validation). No gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The only parameter 'name' is enriched by the description's mention of 'by name' and reference to .json files in builds/, adding meaning beyond the schema's generic title. Schema coverage is 0%, so the description compensates well.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool loads a previously saved build by name, referencing saved .json files in builds/. This distinguishes it from sibling tools like new_build or export_build.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description tells users to look in builds/ for .json files, providing context for usage. It does not explicitly mention when not to use the tool, but the purpose is clear enough to differentiate from alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

new_buildA

Start a fresh build on an empty baseplate of width x depth studs. Replaces the current build (previous one stays saved on disk).

ParametersJSON Schema

Name	Required	Default
`name`	No	build
`depth`	No
`width`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description bears full responsibility for behavioral disclosure. It clearly states that the tool 'replaces the current build' (destructive to in-memory state) while preserving previous saves, which is key for a mutation tool. This goes beyond basic description.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the core purpose. Every sentence adds value without redundancy. Highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite missing annotation and parameter coverage, the description covers the essential behavior and side effects for a simple tool. A small gap is the lack of mention about return type or success confirmation, but with an output schema present, this is acceptable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It adds meaning for 'width' and 'depth' by linking them to the baseplate dimensions, but omits the 'name' parameter entirely. Partially helpful but incomplete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action 'Start a fresh build' and the resource 'empty baseplate of width x depth studs'. It distinguishes from sibling tools like load_build and get_build by indicating it creates a new build, not loading or viewing existing ones.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for starting a new build, but does not explicitly state when to use versus alternatives (e.g., load_build, get_build). No 'when not' or prerequisite conditions are provided, leaving inference to the agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

place_brickA

Place a part with its minimum-x,y corner at stud (x,y), bottom at plate height z (z=0 on the ground; on top of a brick placed at z=0 means z=3). rotation is 0, 90, 180 or 270 (90/270 swap the footprint; slopes descend toward +y at 0 and rotate with the piece). Fails with an explanation if the placement collides, floats, or leaves the build area.

ParametersJSON Schema

Name	Required	Default
`x`	Yes
`y`	Yes
`z`	Yes
`part`	Yes
`color`	No	red
`rotation`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.1/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description transparently explains the tool's behavior, including coordinate system, rotation, and failure conditions. With no annotations provided, it adequately covers the behavioral aspects needed for correct usage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded with the primary function. It packs information efficiently, though minor structuring improvements could enhance readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity, the description covers tool behavior, parameters, and failure conditions. It does not describe success return, but an output schema exists, making this acceptable. The description is sufficiently complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds meaning for x, y, z, and rotation parameters, explaining their coordinate conventions and behavior. However, it does not explain 'part' or 'color' parameters. With 0% schema description coverage, it partially compensates but leaves gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: placing a part with specific coordinate conventions and rotation. It distinguishes itself from siblings like 'remove_brick' and others by specifying its function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides extensive usage guidelines, including coordinate conventions, rotation effects, and failure modes. It implicitly tells when to use the tool but lacks explicit statements about when not to use it or alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

remove_brickA

Remove a piece by id. Refused if other pieces would be left floating.

ParametersJSON Schema

Name	Required	Description	Default
`piece_id`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses the refusal condition, which is a key behavioral trait, but omits details on success behavior, authorization needs, or destructiveness.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two efficient sentences: first states the action, second states a critical condition. No filler, front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter tool with an output schema, the description is minimal but covers the essential purpose. Missing return value description and prerequisites (e.g., piece must exist).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but the description only adds 'by id', which is redundant given the schema's title 'Piece Id'. It does not explain the parameter's format, constraints, or role beyond identification.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Remove a piece by id') and adds a specific condition ('Refused if other pieces would be left floating'), making it distinct from sibling tools like place_brick or new_build.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use (safe removal) and when not (if pieces would float), but does not explicitly name alternatives or provide a when-not-to-use list. The condition serves as a guideline.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

view_layersA

Top-down ASCII map of each plate layer (pieces shown by id, '.' empty). Optionally limit to plate range [z_from, z_to).

ParametersJSON Schema

Name	Required	Description	Default
`z_to`	No
`z_from`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description fully describes the output format (ASCII map, piece IDs, empty dots) and optional range behavior. However, it omits details like output being plain text or how layers are separated, which could be inferred from an output schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no wasted words. The first sentence establishes the core functionality, the second explains the optional parameters. Efficient and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description, combined with the output schema presence, covers the main behavior and parameter usage adequately. It could expand on how multiple layers are displayed, but overall it is sufficiently complete for a simple read tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds meaning to the two parameters by explaining they define an optional plate range using bracket notation [z_from, z_to). With 0% schema coverage, this clarification is valuable, though it could specify inclusivity explicitly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool outputs a top-down ASCII map of plate layers with pieces shown by IDs and '.' for empty, and distinguishes it from siblings like export_build or list_parts. The verb 'view' and resource 'layers' are specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit when-to-use or when-not-to-use instructions are given. The optional range is noted but alternatives or prerequisites are not mentioned, leaving the context ambiguous for an agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

8 tool updatesv0.1.0Jul 7, 2026
- First observedexport_build
- First observedget_build
- First observedlist_parts
- First observedload_build
- First observednew_build
- First observedplace_brick
- First observedremove_brick
- First observedview_layers

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.2/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose and target action: export, get, list, load, new, place, remove, view. No overlap or ambiguity among them.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case, such as export_build, list_parts, place_brick, making them predictable and easy to understand.

Tool Count5/5

With 8 tools, the server is well-scoped for a LEGO building assistant, covering essential operations without being overly complex or sparse.

Completeness4/5

The tool set covers core building workflows (create, read, delete, export) but lacks an update tool for bricks (e.g., reposition) and a way to list saved builds, requiring minor workarounds.

Maintenance

ActivityStale

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

mcp A
ai.llmse
Public MCP server for the LLM Search Engine
Search RAG Systems Developer Tools
102
mcp-aichatOAuth
io.github.AceDataCloud
MCP server for AI dialogue using various LLM models via AceDataCloud
AI & Machine Learning
2
Gessa: game asset generation for AI agentsOAuth
ai.gessa
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
AI & Machine Learning Image & Video Processing Audio Processing
1
H-Index A
ai.xr-utilities
Capability registry for the agentic economy. Semantic search over verified MCP server listings.
Search Documentation Access
2

Related MCP Servers

Brick Builder MCP App
Design Tools
dend
A
license
Not graded
quality
C
maintenance
A Three.js MCP server for designing 3D brick constructions, enabling AI or interactive placement of bricks through natural language and providing tools to manage and export scenes.
Updated 6 months ago (2026-03-16 21:55 UTC)
23
MIT
mcp-toolbox
Developer Tools Command Line Design Tools
fastmcp-me
A
license
Not graded
quality
D
maintenance
A comprehensive MCP server enabling LLMs to execute commands, manage files, interact with Figma, search the web, generate images, and more, extending their capabilities beyond text generation.
Updated a year ago (2025-10-02 20:19 UTC)
Apache 2.0
cadkit
Design Tools Developer Tools
saltyeg
A
license
B
quality
B
maintenance
An MCP server for parametric part modeling in Onshape, producing fully-defined, variable-driven sketches and features. It enables LLMs to create editable CAD models using semantic selection and geometrically grounded constraints.
Updated 2 months ago (2026-06-25 20:59 UTC)
33
MIT
loadbench-mcp
Developer Tools
jeongho54
A
license
A
quality
C
maintenance
An MCP server that provides structural load and stability math (tipping, support reactions, beam checks) that language models often get wrong, enabling AI assistants to compute accurate engineering estimates.
Updated 2 months ago (2026-06-29 11:10 UTC)
3
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Axel-Jalonen/lego-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server