forge3d-mcp
forge3d-mcp lets an AI agent run a full 3D-model toolchain: plan, generate, inspect, validate, repair, render, package, and hand off models while keeping geometry out of context.
Discover geometry engines and diagnose runtime/install gaps with
list_backendsanddoctor.Turn a brief into a checkable model spec with purpose, units, dimensions, references, and poly budget.
Create models using
autorouting or explicit backends: procedural trimesh, image-to-3D derivation, OpenSCAD, Blender, CadQuery, or hosted text-to-3D.Optionally scale to spec, render previews, make self-contained Three.js viewers, and return validation results.
Generate math-defined shapes and procedural rocky planets with baked PBR textures.
Compose multiple models into one self-contained Three.js scene viewer.
Inspect mesh facts, produce compact model cards, validate against print/web/game/cad profiles, repair meshes, and convert formats such as STL, OBJ, PLY, OFF, GLB, glTF, and DAE.
Render CPU preview images from multiple views.
List hosted providers and optionally run authenticated checks.
Read and list generation jobs.
Get review checklists and write multi-agent/team handoff packets.
Run the whole review loop in one call: validate + render + model card.
Operate as an MCP server locally or over HTTP with credentials, scopes, health, rate limiting, structured logs, and job recovery (per README).
Provides a geometry backend that drives Blender for organic forms, bevels, subdivision, materials, rigging, and animation.
Exports models as GLB/glTF and embeds GLB data directly into shareable viewer pages.
Provides a geometry backend that drives OpenSCAD for hard-surface CSG parts such as brackets, enclosures, and jigs.
Generates single-file Three.js viewer pages and an embeddable custom element for displaying exported GLB models.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@forge3d-mcp make a 3D-printable wall bracket for a 32mm pipe and validate it"
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.
forge3d
A 3D-model toolchain any AI agent can drive. One MCP server, one agent skill, six interchangeable geometry engines, a validation layer that knows what "correct" means for print vs web vs game, and a Three.js viewer that turns a mesh into a single HTML file you can send to anyone.
Most "AI makes 3D" demos stop at a pretty mesh in a viewport. The hard parts are everything after: is it watertight, is it the right size in millimetres, will it survive a 60k-triangle budget, can the next agent pick up where this one left off without re-reading a megabyte of vertices. forge3d is built around those.

The whole flow, rendered by forge3d itself — create_shape → validate_model →
make_viewer. Every frame comes from the library's own CPU renderer, so the GIF
cannot show anything the code does not produce.
Try it in one command
pip install "forge3d @ git+https://github.com/chaudharyvivek1/forge3d.git"
forge3d demoforge3d demo needs no Blender, no OpenSCAD, no API key and no network. It builds
a shape from an equation, validates it, renders previews and writes a
self-contained viewer page, then prints every path. Everything else in this README
is optional on top of that.
Nothing in that image is stock: the geometry came from examples/procedural_chair.py
and the render from forge3d.render — the same loop an agent runs.
Open examples/chair.html for the interactive version.
Related MCP server: clayform
What it actually does
brief ──► plan_model ──► create_model ──► validate_model ──► repair_model ──► review_model
│ │
├──► previews (PNG, so the agent can *see* it) │
└──► viewer (single-file Three.js page) ◄─────────┘Step | Tool | What it prevents |
Brief |
| generating from a vague prompt with no scale or purpose |
Build |
| being locked into one engine |
Inspect |
| pasting geometry into a context window |
Check |
| shipping a non-manifold mesh to a printer |
Fix |
| silent holes, flipped normals, absurd poly counts |
Verify the fix |
| a repair that "worked" but changed the part's dimensions |
Look |
| the agent guessing instead of iterating |
Ship |
| needing a host to show someone the result |
Hand off |
| two agents diverging on the same model |
Stop |
| a generation you no longer want, running until the process is killed |
Install
Straight from the repository — one line, no clone:
pip install "forge3d @ git+https://github.com/chaudharyvivek1/forge3d.git"Or for development, with the preview renderer:
git clone https://github.com/chaudharyvivek1/forge3d.git
cd forge3d
pip install -e ".[render,dev]"PyPI: publishing is automated —
.github/workflows/release.ymlbuilds the sdist and wheel, runstwine check, installs the wheel in a clean venv and smoke tests it, then publishes via PyPI trusted publishing on av*tag. It is waiting on a one-time setup step (below); until that is done,pip install forge3ddoes not resolve and thegit+https://line above is the install path.
Optional engines — install only what you need:
# exact CSG parts (brackets, enclosures)
sudo apt install openscad # macOS: brew install --cask openscad
# Windows: winget install OpenSCAD.OpenSCAD
# organic forms, bevels, materials, animation
sudo snap install blender --classic # macOS: brew install --cask blender
# Windows: winget install BlenderFoundation.Blender
# real B-rep CAD with STEP export
pip install cadquery
# decimation in repair_model
pip install fast-simplification
# boolean unions in trimesh (procedural backend)
pip install manifold3dCheck what this machine can actually do — never guess:
forge3d doctor # OS, Python, engines, packages, workdir, and how to fix gaps
forge3d backends # just the engine listdoctor is also an MCP tool, so an agent can diagnose its own runtime instead of
guessing why a backend is unavailable. It reports whether an env var is set,
never its value — an API key is not echoed back.
Works on Linux, macOS and Windows, in Docker, and in CPU-only agent sandboxes. The full matrix, including what does not work where, is in docs/platforms.md.
Quick start (agent)
Add to Claude Desktop, Cursor, or any MCP client:
{
"mcpServers": {
"forge3d": {
"command": "forge3d-mcp",
"env": { "FORGE3D_WORKDIR": "/absolute/path/to/forge3d-work" }
}
}
}For a remote agent or your own app, run it over HTTP instead:
pip install "forge3d[http]"
forge3d-mcp --http 8000 # loopback only, no auth
FORGE3D_HTTP_TOKEN=$(openssl rand -hex 32) \
forge3d-mcp --http 8000 --host 0.0.0.0 # network, one owner
# several callers: one key each, narrowest scope that works
FORGE3D_API_KEYS='{
"sk-readonly": {"id": "ci", "scopes": ["read"]},
"sk-design": {"id": "design", "scopes": ["read", "write"]},
"sk-builder": {"id": "build", "scopes": ["read", "write", "exec"]}
}' forge3d-mcp --http 8000 --host 0.0.0.0The HTTP transport binds 127.0.0.1 by default and refuses a public bind
without a credential — v0.2.0 bound 0.0.0.0 with no authentication, which
meant anyone who could reach the port could run arbitrary model code. HTTP mode
also forces subprocess isolation for that code.
Since 0.7.0 a request resolves to a principal: a key's id, its scopes
(read, write, exec, admin), and — when the server holds more than one key —
its own work directory, so one caller cannot read another's models. exec is
required before any backend runs caller-supplied code. The single
FORGE3D_HTTP_TOKEN still works and is treated as the owner, so nothing about an
existing deployment changes. Read docs/security.md before
exposing it anywhere; it states plainly what is still not protected.
Then a single call gets you from brief to shareable page:
create_model(
prompt="a modern side chair with cross braces",
name="chair",
purpose="game",
backend="procedural",
source=open("examples/procedural_chair.py").read(),
dimensions={"x": 450, "y": 480, "z": 850},
units="mm",
scale_to_spec=True,
)
# -> { "ok": true, "path": ".../chair.glb", "viewer": ".../chair.html",
# "validation": { "ok": true, "summary": "PASS with 1 warning(s) ..." }, ... }Quick start (human, no agent)
forge3d plan --prompt "wall bracket for a 32mm pipe" --purpose print --dims x=120,y=60,z=40
forge3d create --name chair --purpose game --backend procedural \
--source examples/procedural_chair.py --dims x=450,y=480,z=850 \
--scale-to-spec --viewer
forge3d validate output/chair.glb --profile print
forge3d render output/chair.glb
forge3d viewer output/chair.glb --out chair.htmlThe six engines
Backend | Needs | Best for | Weak at |
| nothing (trimesh) | precise dimensions, repeated structure, editable output, offline | organic forms |
| nothing (PIL) | real geometry from a real image: relief plaques, lithophanes, extruded logos with holes | reconstructing what the photo does not show |
|
| hard-surface CSG, brackets, enclosures, jigs | sculpting, texturing |
|
| bevels, subdivision, materials, rigging, animation | exact mechanical dims |
|
| manufacturing, STEP deliverables, fillets | organic forms |
| a provider key or | stylised props, characters, textured meshes fast | exact scale, watertight print geometry |
backend="auto" routes from the spec: print → OpenSCAD if present, cad →
CadQuery, game → Blender, web with references → hosted, otherwise
procedural. The routing table is data (backends/registry.py), so it is
testable and easy to change.
Image to 3D
Two different things get called "image to 3D", and conflating them is how a demo
never ships. Reconstruction (infer the unseen side of an object) needs a
neural model and a GPU — route that to backend="hosted". Derivation —
computing real geometry from pixels — is the image backend, and it is
deterministic, needs no GPU, and produces a watertight solid:
forge3d create --name plaque --purpose print --backend image \
--source portrait.jpg --dims x=100,y=75,z=8 # relief / lithophane
forge3d create --name sign --purpose print --backend image \
--source logo.png --dims x=80,y=80,z=4 # extruded silhouetteA relief costs exactly $$4(g-1)^2 + 8(g-1)$$ triangles at grid $$g$$, and the grid
is shrunk automatically to fit poly_budget before generating. Holes in a mask
survive as real holes. Full detail, including what it will not do:
docs/image-to-3d.md.
Cloud providers
Real adapters for Meshy, Tripo and Rodin behind one job-shaped
interface, plus the original generic worker — existing FORGE3D_HOSTED_URL
deployments keep working unchanged.
forge3d providers # what is configured here
forge3d providers --check # live authenticated requestcreate_model(backend="hosted", mode="cloud", prompt="a ceramic teapot")Every adapter reports verified — whether it has been run against a live account.
Only the generic worker has; the commercial three are written from public docs and
say so, in the CLI, in list_providers, and in the job metadata. --check settles
it in one command. Interface, status normalisation and how to add one:
docs/providers.md.
Make anything from an equation
15 shape families defined by maths, callable by name. No vertex loops, no noise code, no "almost watertight" caps:
create_shape(shape="supershape", params={"m": 6, "n1": 0.3}, resolution=96)
create_shape(shape="involute_gear", params={"teeth": 24}, export_format="stl")
create_shape(shape="torus_knot", params={"p": 2, "q": 3})supershape (Gielis superformula) covers flowers, stars and organic blobs.
involute_gear is a real meshing tooth profile, not a decorative one.
lathe turns any 2D silhouette into a solid of revolution. Plus
spherical_harmonic, superellipsoid, lissajous, spring, seashell,
twisted_prism, bumpy_sphere, and the open surfaces mobius, helicoid,
catenoid. list_shapes returns every equation with its parameters.
All 11 solids are watertight and pass the print profile — asserted per shape in
the test suite, because "looks right" and "is printable" are different claims.
Exports to GLB, STL, OBJ, PLY, OFF, glTF and DAE. Equations and parameter tables:
docs/surfaces.md.
Procedural planets and scenes
A website hero scene needs four rocky planets, not four bracket models. The
planets generator is that shape family, done once and tested:
create_planet(radius=55, seed=11, canyon=True, subdivisions=5, texture_resolution=512)
# -> GLB with baked albedo + normal + metallic-roughness, spherical UVs, watertight
make_scene_viewer(items=[
{"path": "mars-prime.glb", "position": [0, 0, 0]},
{"path": "mars-canyon.glb", "position": [105, -60, -80]},
], title="Four-Planet Mars Scene")
# -> one self-contained Three.js page: shared sun, 9k-point starfield, orbit controlsNoise is sampled in 3D on the sphere (no UV seam), craters are analytic bowls with rims, and textures are baked from the same fields as the geometry so the colour and the silhouette always agree. Everything is seeded, so the hero image is reproducible. Reference scene: 51k triangles, ~17 s, 3.5 MB page — see docs/geometry.md for the size budget and what it will not do.
ModelSpec.mode — local never routes to a paid provider, cloud never
routes to a local engine, auto decides on fit. A tool that quietly upgrades you
into a billable API call is not being helpful.
Production behaviour
GET /health— no token needed, reports version, uptime, exec mode, sandbox in force, job counts.Concurrency —
FORGE3D_MAX_CONCURRENT(default 2) with a bounded queue (FORGE3D_QUEUE_WAIT, default 30 s), then an honest "server busy" rather than a silent wait.Rate limiting —
FORGE3D_RATE_LIMITper token/IP,429+Retry-After.Retries — hosted calls back off exponentially with jitter on 5xx and connection errors, never on 4xx.
Logs —
FORGE3D_LOG_JSON=1gives one JSON object per tool call and per HTTP request.Job recovery — atomic records, job-scoped output dirs, and orphaned jobs marked
interruptedon restart.
Full detail, including what is not handled: docs/reliability.md.
Three.js
Two ways, both in the repo:
Single-file page — make_viewer embeds the GLB as a data URI, so the HTML
needs no server, no CORS and no hosting. The model is embedded; three.js still
loads from a CDN by default, so for an air-gapped machine point
FORGE3D_THREE_URL at a local mirror of three before building the page:
forge3d viewer output/chair.glb --out chair.html
FORGE3D_THREE_URL=http://localhost:8080/three forge3d viewer output/chair.glb --out chair.htmlEmbeddable element — for your own app, a custom element that takes a URL:
<script type="importmap">
{"imports":{"three":"https://unpkg.com/three@0.169.0/build/three.module.js",
"three/addons/":"https://unpkg.com/three@0.169.0/examples/jsm/"}}
</script>
<script type="module" src="/forge3d-viewer.js"></script>
<forge3d-viewer src="/models/chair.glb" height="480" autorotate grid></forge3d-viewer>Events: forge3d:loaded (detail.triangles), forge3d:error.
See docs/threejs.md.
Why the context-window rules matter
A 100k-triangle GLB is a few megabytes; as text it is millions of tokens. So
every tool in forge3d takes and returns paths, never geometry. The one way to
describe a model in context is model_card — roughly 300 tokens:
**chair.glb** — glb
96 tris · 418.77 x 412.56 x 850 mm · watertight · 8 body
validation: PASS with 1 warning(s) — game profile (single_body)
ship as: .glbMulti-agent, multi-person
handoff.py defines the packet that lets a second agent — or a designer and a
3D artist — take over without re-deriving anything: spec, artifacts, checks,
owners, open questions, and who is next. It writes both JSON (for agents) and
Markdown (for humans). See docs/multi-agent.md.
create_handoff(
spec=spec, artifacts={"model": "chair.glb", "viewer": "chair.html"},
backend="procedural",
checks=checklist("game"),
owners={"design": "priya", "geometry": "agent-a"},
next_agent="review-agent",
)Releasing
Tagging is the release:
git tag v0.6.7 && git push origin v0.6.7The workflow verifies the build before it uploads anything, so a broken README or bad metadata fails in CI rather than on PyPI.
One-time setup, on PyPI (not in this repo): add a trusted publisher at
https://pypi.org/manage/account/publishing/ with owner chaudharyvivek1,
repository forge3d, workflow release.yml, environment pypi. No API token is
stored anywhere. If you would rather use a token, add the secret PYPI_API_TOKEN
and swap the with: block in the workflow.
To check the pipeline without publishing, run the workflow manually — the publish
job only runs on a v* tag.
Repository layout
src/forge3d/
spec.py the brief as data — purpose, units, dimensions, budget
backends/ procedural · image · openscad · blender · cadquery · hosted
providers/ meshy · tripo · rodin · generic worker (one job-shaped contract)
geometry/ generators: planets (terrain, craters, PBR bake), surfaces (15 equation families)
validate.py profile-based checks, every failure carries a fix hint
repair.py merge, drop, fill, re-orient, decimate — plus a before/after report
render.py CPU previews (matplotlib) — works headless, no GPU
viewer.py single-file Three.js page
viewer_assets/ template.html + forge3d-viewer.js custom element
platform_support.py binary discovery, UTF-8 subprocess, thread-safe timeouts, doctor
auth.py principals, API keys, scopes, per-tenant work directories
http_server.py HTTP transport: loopback default, key auth, health, rate limit
sandbox_runner.py the child process for FORGE3D_EXEC_MODE=subprocess
context.py model cards — the only sanctioned way to describe a mesh
handoff.py checklists + multi-agent handoff packets
jobs.py durable job records: heartbeat, crash recovery, cancellation
server.py the MCP surface (22 tools)
cli.py same capabilities without an agent
skill/ agent skill: SKILL.md + references
docs/ architecture, security, reliability, providers, image-to-3d, geometry, surfaces,
platforms, backends, threejs, multi-agent, licensing
docs/audit/ the 0.7.0 audit: architecture, feature verification, security, quality,
issues, roadmap, ratings
examples/ chair (trimesh), bracket (OpenSCAD), gear (bpy), plate (CadQuery)
tests/ pytest — unit, platform and regression suites
Dockerfile CPU-only image, non-root, /work volumeSecurity
Two things worth knowing before you point this at anything other than your own machine:
Agent code execution. The procedural, cadquery and blender backends run
code the agent wrote — and all three are now refused centrally when
FORGE3D_ALLOW_CODE_EXEC=false, not just the procedural one.
FORGE3D_EXEC_MODE=subprocess runs them in a killable child with rlimits, and
FORGE3D_SANDBOX wraps that in bubblewrap where available. Neither is a sandbox
against a determined attacker — for that, use the container and keep the caller
trusted.
Remote images are fetched through a guard that refuses loopback, private and link-local addresses (revalidated after every redirect), caps the body size, and requires the bytes to decode as an image inside a pixel budget.
The HTTP transport requires a credential for any non-loopback bind, compares
it in constant time, forces subprocess isolation, and has an in-process token
bucket (FORGE3D_RATE_LIMIT). That limiter is per-process and in-memory — it is
not a distributed or billing-grade quota. It does not do TLS; put a reverse proxy
in front for that.
Authentication is not authorization, so 0.7.0 added the second half. A key
maps to a principal with scopes: read (inspect, validate, list), write
(create, repair, convert, render, cancel), exec (additionally required before a
backend runs code you supplied) and admin (doctor, which discloses the host's
inventory). A tool with no declared scope is closed by default. With more than one
key, each principal gets <workdir>/tenants/<id> and reads outside it are
refused — a guessed path is not enough to fetch someone else's mesh.
Still not implemented, and not pretended otherwise: per-object ACLs (two keys cannot share one project), user accounts or OAuth, an audit log beyond the structured stderr lines, and multi-instance rate limiting.
Full detail, including the threat model and what is deliberately not covered: docs/security.md.
Honest limitations
Textures. The local engines produce geometry, not painted PBR materials. For textured output, route to a hosted text-to-3D service.
Hosted adapter. Provider APIs (Meshy, Tripo, Rodin, Hunyuan3D) differ.
hosted.pyspeaks one small documented contract — point it at a thin worker. It does not pretend to be a drop-in client for all of them.Rigging. Blender can rig; forge3d does not generate skeletons or weights for you. Auto-rig quality varies badly.
Preview renders are review-quality, not beauty shots. For beauty, the Three.js viewer with an environment map is the better tool.
Licensing. Output rights differ sharply between hosted services. That is your provider's terms, not this repo's. See
docs/licensing.md.Provider adapters exist but are not live-verified. Meshy, Tripo and Rodin have real adapters written from their public docs; only the generic worker has been run against a live endpoint.
list_providersandforge3d providers --checkreport the difference rather than hiding it.Subprocess isolation is not a security boundary. It gives real cancellation and resource ceilings; it does not stop a child process reading your files.
Licence
MIT — see LICENSE. Built by Vivek Chaudhary.
Available Tools
21 toolschecklistChecklistA
Get a review checklist: brief, geometry, print, web, game or delivery.
Tick items as they are verified and carry the dict into the handoff.
Inputs: name. Returns: object
convert_modelConvert ModelB
Convert between mesh formats: stl, obj, ply, off, glb, gltf, dae.
Delivery cheat-sheet: print -> stl, web/game -> glb, archival/CAD -> step (step needs the cadquery backend, not this tool).
Inputs: path (required), fmt, out_path. Returns: object
create_handoffCreate HandoffB
Write a handoff packet (JSON + Markdown) so the next agent or teammate needs no context.
owners maps a role to a name, e.g. {"design": "priya", "geometry": "agent-a"}.
Inputs: spec (required), notes, checks, owners, +4 more. Returns: object
create_modelCreate ModelB
Generate a 3D model and return its card, validation report and viewer link.
backend='auto' routes from the spec; pass an explicit engine when you know
better. source is the code that builds the model for the code backends:
procedural — python defining build() -> trimesh object
openscad — OpenSCAD CSG source
blender — a bpy script
cadquery — python assigning result
hosted — optional prompt override for a text-to-3D service
Returns path (the mesh), viewer (a single-file HTML page you can hand to
anyone) and validation. Always read validation.ok before calling it done.
Inputs: mode, name, seed, style, +14 more. Returns: object
create_planetCreate PlanetA
Generate a procedural rocky planet: terrain, craters, optional canyon, baked PBR maps.
Deterministic — the same seed always produces the same planet, so a website hero image is reproducible. Writes albedo, normal and metallic-roughness textures with correct spherical UVs and embeds them in the GLB.
Use this instead of writing noise code inside create_model: the crater
profile, seamless 3D noise sampling and UV layout are already correct here,
and a hand-rolled version usually gets at least one of them wrong.
radius is in world units. subdivisions: 4 = ~5k faces, 5 = ~20k, 6 = ~82k. texture_resolution 0 disables baking (vertex colours only, much smaller file).
Inputs: name, seed, canyon, radius, +10 more. Returns: object
create_shapeCreate ShapeA
Build a shape from a mathematical equation and export it to any mesh format.
Pick a family with list_shapes, then pass the numbers. Everything is
deterministic: the same shape and params give the same mesh every time.
resolution controls detail (12-512). It is the one knob you usually need — raise it for a hero asset, lower it for a game prop or a phone scene.
export_format: glb (default, web), stl (print), obj, ply, off, gltf, dae. GLB and STL are always written; export_format adds one more.
Shapes marked closed: false (mobius, helicoid, catenoid) are open surfaces —
visually correct, but not printable solids. validate_model will say so.
Inputs: name, shape, params, purpose, +5 more. Returns: object
doctorDoctorA
Diagnose this runtime: OS, Python, which engines exist, what is missing and how to fix it.
Call this when a backend reports itself unavailable, or before telling a user that something cannot be done. It returns copy-pasteable install commands for the current OS rather than a generic error.
Inputs: no named parameters. Returns: object
get_jobGet JobA
Read one generation job by id (status, output path, log, error).
Inputs: job_id (required). Returns: object
inspect_modelInspect ModelB
Geometry facts for a model file: triangles, dimensions, watertightness, bodies.
Cheap and safe on broken meshes. Use this instead of opening the file.
Inputs: path (required). Returns: object
list_backendsList BackendsA
List every geometry engine with its availability, strengths and weaknesses.
Call this first when a model needs something other than the default. The
available flag is ground truth for this machine — do not guess.
Inputs: no named parameters. Returns: object
list_jobsList JobsC
Recent generation jobs, newest first.
Inputs: limit. Returns: object
list_providersList ProvidersA
List text-to-3D providers: what is configured here, and what is verified.
Call this before choosing backend="hosted". available means credentials
exist on this machine; verified means the adapter has been exercised against
a live account by the maintainer. Most commercial adapters are NOT verified —
pass check=true to make a real authenticated request and settle it.
Inputs: check. Returns: object
list_shapesList ShapesA
Catalogue of maths-defined shapes, with the equation and parameters for each.
Call this before create_shape. Every entry states whether it is a closed
solid (safe to print) or an open surface (visual only), and what each
parameter does — so you can pick a family instead of writing vertex loops.
Inputs: no named parameters. Returns: object
make_scene_viewerMake Scene ViewerC
Compose several models into ONE self-contained Three.js page.
Inputs: items (required), title, out_html. Returns: object
make_viewerMake ViewerB
Build a single self-contained Three.js HTML page with the model embedded.
The mesh is embedded as a data URI, so the page needs no server, no CORS and
no hosting — send the file to anyone. Note that three.js itself loads from a
CDN by default: for an air-gapped machine, set FORGE3D_THREE_URL to a local
mirror before building the page. For embedding inside an existing web app,
use the forge3d-viewer custom element instead (viewer_assets/forge3d-viewer.js).
Inputs: path (required), spec, title, out_html. Returns: object
model_cardModel CardA
A ~300-token summary of a model file — the only safe way to describe it in context.
Never read mesh data directly; call this and pass the path onward.
Inputs: path (required). Returns: object
plan_modelPlan ModelB
Turn a vague request into a checkable model spec, before generating anything.
purpose is print | web | game | cad | any and it changes what "correct"
means. dimensions are real-world sizes in units, e.g. {"x": 180, "y": 90,
"z": 75}. The response lists what is still missing — ask the user for those
instead of inventing them.
Inputs: mode, name, style, units, +5 more. Returns: object
render_modelRender ModelA
Render CPU preview images (iso, front, right, top) so you can see the model.
Use this after every generation. A model you have not looked at is a guess.
Inputs: path (required), size, views. Returns: object
repair_modelRepair ModelB
Merge, drop, fill, re-orient — and optionally decimate — a broken mesh.
Writes a new file (never overwrites the input unless you pass the same path). Returns the actions taken so you can tell a human what changed.
Inputs: path (required), out_path, fill_holes, decimate_to, +1 more. Returns: object
review_modelReview ModelA
One call for the whole review loop: validate + render + card.
Use this as the last step before telling a user the model is ready, and after every repair.
Inputs: path (required), spec, previews. Returns: object
validate_modelValidate ModelA
Check a mesh against a delivery profile: print, web, game, cad or any.
Each failure carries a hint. ok is false only when an error-severity
check fails — warnings are judgement calls, errors are blockers.
Inputs: path (required), spec, profile. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 21 tools
Most tools target distinct pipeline stages: backend discovery, planning, generation, inspection, validation, repair, conversion, rendering, viewing, and handoff. There is some potential overlap between create_model, create_shape, and create_planet, and review_model intentionally aggregates validate/render/card, but the descriptions clearly explain when each is appropriate.
The set is mostly consistent verb_noun naming (list_backends, create_model, inspect_model, validate_model, repair_model, convert_model, render_model, make_viewer, create_handoff, review_model). A few outliers such as doctor, model_card, and checklist are still readable and domain-appropriate, but they break the otherwise predictable convention.
At 21 tools, the surface is heavy for an MCP server and sits at the borderline of the recommended range. The broad 3D generation/validation/delivery domain justifies many of them, but some grouping or consolidation could reduce cognitive load.
The core lifecycle is well covered: plan, generate, inspect, validate, repair, convert, render, review, and hand off. Minor gaps remain around job/model cleanup or cancellation, explicit scene creation, and direct STEP export, but agents can generally work around these.
Maintenance
Related MCP Connectors
Parametric 3D CAD for AI agents: build print-ready parts, check them, export STL, 3MF or STEP.
Generate 3D models, worlds, PBR materials, and coordinated asset packs from AI agents.
A browser 3D CAD for your AI: it scripts real-size models, uCAD builds them and returns pictures.
Text-to-CAD: build exact STEP or 3MF/STL on the server, each stated requirement measured.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables AI agents and MCP clients to perform 3D asset creation and verification: exact b-rep CAD, GLB validation with embedded certificates, mesh inspection, and physics scenes, with most tools running without Blender.3648 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to model, sculpt, rig, animate and bake particle effects by editing a semantic scene document, with built-in software rendering, measurable critics that flag floating or broken geometry, and game-ready glTF export. It exposes templates, atomic edit batches, motion and effect previews, undo history, and no GPU, browser, or Blender required.10 npmApache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to design, modify, and verify exact B-rep 3D CAD models by running build123d scripts on an OpenCascade kernel, with live three.js preview, collision and FDM printability checks, text-based spatial perception, user notes/sketch annotations, version history, and one-click export to OrcaSlicer.1MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI coding agents to turn natural-language descriptions and dimensional sketches into validated, watertight 3D-printable STL files by compiling build123d scripts, inspecting meshes, and rendering deterministic multiview previews.MIT