Skip to content
Agentmart
Submit a tool

b123d-print

Vibe CAD for 3D printing: design, check and export printable parts with build123d.

Connector by KD5RYN · GitHub account verified by the MCP Registry

IndexedMITLocal (stdio)★ 1
Write a review

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/kd5ryn-b123d-print

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Vibe CAD for 3D printing: design, check and export printable parts with build123d.

Use cases: code-generation, ui-design

Reviews

Write a review

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Tools
13 read · 10 write · 0 delete · 10 not yet classified
Secrets
None asked for
Install scripts
Not scanned yet
Runs as
Python package

Tools by what they do 33

Read from the source code; the running server may list different tools.

Read 13 · Look things up without changing anything.

  • check_fit
  • compare
  • describe_model
  • hardware_list
  • list_edges
  • list_faces
  • list_parts
  • list_versions
  • measure
  • read_guide
  • read_part
  • render_preview
Show 1 more tools
  • suggest_orientation

Write 10 · Create, change, send or run things.

  • build_part
  • download_part
  • make_template
  • new_part
  • restore_version
  • save_setup
  • save_version
  • set_params
  • upload_reference
  • write_part

Not yet classified 10 · We could not tell from the name and description.

  • before_after
  • check
  • design_metrics
  • diagnose_failure
  • export
  • params
  • recipe
  • section
  • trace_outline
  • use_printer

Files it touches

  • Any path the agent passes to its tools

Tools (33)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

  • before_after

    For a remix: the original and the remix side by side, and the original colored by how far the remix is from it (compare's deviation view: green = unchanged, red = changed), with compare's score and metrics. The original is what build() loads with import_model, or what the script's original(d) returns. export writes the same two images when it writes PNGs.

  • build_part

    Run the part script (sandboxed, with a timeout) and report, per variant and part: bounding box size and min/max (mm), volume (mm^3), solid count, is_valid, the Dims values, and any error with its traceback; and under "timing" each piece's face count and build time, with a hint for a piece that is slow or dense. variant: key from VARIANTS ('standard' = ''). parts: comma-separated piece names from build(): build only those (lazy pieces: the others are never built). Built pieces are cached in out/.cache/, so render_preview, section, check and export reuse them while the script, its Dims and the s…

  • check

    Run the print checks: validity, overlap between assembly parts (incl. stand-ins), overhangs > 45 deg from vertical in print orientation (bed face ignored) and bridge spans, thin features (walls under one line width fail), round-topped horizontal holes, fillets on bed edges, gaps between parts printed in place, the script's Wall checks (thinnest material around deep cuts) and Probes. The fit between an assembly's pieces (hole alignment, gaps) is a separate tool, check_fit, unless the script lists Mates() in checks(d). Fix every FAIL; report every WARN. On a remote server (HTTP/SSH) the part is …

  • check_fit

    How the pieces of assembly(d) fit together, as placed (stand-ins count as obstacles): interference (pairs that overlap: the volume and where; pairs closer than the clearance without touching: the gap and where; faces resting on each other are contact) and hole alignment (round holes of two pieces on one axis are partners: offset beyond hole_tol mm, default 0.2, fails; their diameters read as screw holes, clearance + pilot / insert / nut, and a pair no single screw explains warns; a hole whose axis runs into solid material of the next piece has no partner). Male/female joint pairs from the scri…

  • compare

    Compare a part with a reference model: bounding box, volume and surface area differences, surface distances (mean, Hausdorff) after aligning orientation, an F-score, a 0-100 score and pass/fail. reference, candidate: STL, 3MF or STEP files inside the workspace, as paths relative to it (e.g. 'refs/bracket.stl', 'parts/bracket/out/print/bracket.3mf'). thresholds: optional overrides, comma-separated name=value (e.g. 'hausdorff_mm=2,volume_rel=0.05'). image: also return a view of the reference colored by deviation (green = matches, red = off); size: 'normal' or 'small' (~800 px wide); inline=False…

  • describe_model

    Inspect an original model before remixing it: format, units (and whether they look wrong), size, volume, triangles and faces before/after merging coplanar triangles, how much is curved (faceted), round holes (diameter, axis, center), repairs needed, the designer/license metadata the file carries, and a suggestion: MODIFY it or REDRAW it. part: the part it is for. file: a name in parts/<part>/ref/ (or a workspace path such as 'refs/x.stl'). scale: '' (as the file says), a factor, or the unit the file was drawn in ('inch', 'cm'). image: also a 6-view render (saved as parts/<part>/out/images/<fil…

  • design_metrics

    Design numbers for the design review, per printable part: size and proportions, filament (simple estimate, roughly +-20 %) and cost, print time (rough estimate), supports, shallow slopes that show layer steps, edge treatment (sharp / filleted / chamfered shares, distinct radii and chamfer sizes), mirror symmetry, screw sizes, seam corners, water traps, inside corners, hole edge distance and slenderness across the layers (and the thinnest walls for a style that asks); then the suggestions the part's style triggers, each citing its DS-* rule. Run it after check passes. style: override the part's…

  • diagnose_failure

    The deeper look after a failed or broken build (failed results already carry a short DIAGNOSIS): builds one variant piece by piece, each on its own and without the build cache, and for each piece reports the error with its likely cause and specific fixes (where in the script, the piece, the numbers: e.g. the largest fillet radius that works on those edges), or for a piece that built, what makes it unprintable (invalid solid, zero volume, a 2D shape, not on the bed) and, for an invalid one, which faces and edges are bad, tiny edges and sliver faces left by booleans, and whether part.fix() repai…

  • download_part

    Bring a whole part home from a remote server, in the same layout a local install writes: parts/<name>/<name>.py, parts/<name>/out/ (exports, renders, sections) and parts/<name>/ref/ (reference models). Over HTTP: ONE signed link (no token needed, expires) to a zip of all of it; run `curl -fLo <name>.zip '<link>'` and unzip it in the project folder, then check the files are there. Over SSH: the `b123d-print pull` command that writes the same files. Locally (stdio): says where the files already are. variant: only that variant's out/ files ('standard' = ''); formats: only those out/ files (step, …

  • export

    Export printable parts to parts/<name>/out/, sorted: print/ (3MF, STL, print sheet: for the slicer), cad/ (STEP, GLB), images/, docs/ (BOM, view HTML), README.md. Default: every part, all variants. The files must reach the user: on a remote server download_part brings them home. parts: comma-separated part names from build() to build and export only those; variant: one variant. Uses the pieces cached by an earlier build and leaves files already up to date as they are (templates too); fresh=True builds and writes everything again. formats: comma-separated from step (other CAD: Onshape, Fusion, …

  • hardware_list

    What to buy: the bought hardware the script declares in hardware(d) (screws, inserts, magnets, bearings), as one Markdown table to show the user: Qty | Item | Specification | Used for | Source/link | Status ("check before ordering" where the specification is not confirmed: ask the user, never guess it). Identical items are merged and summed. Offer it when a part declares hardware. name: one part; parts: comma-separated part names to merge into one list (each may be part:variant); neither: every part in the workspace. variant: the variant (default: the standard one). count: how many assemblies …

  • list_edges

    The edges of a printable part, to pick the ones for a fillet or chamfer by id instead of guessing a selector: stable ids (1 = the longest; changed geometry may renumber), type (line, circle, arc, ellipse, spline), length, start and end (or center and radius), convexity (convex: an outside edge; concave: an inside corner; tangent: a smooth joint such as a fillet's side; seam), the turn between its faces and the two faces it joins (flat faces by their list_faces id, curved ones by type). Filters: face (an id, side or 'x,y,z' as in list_faces: its edges), kind, convexity, near ('x,y,z': edges wit…

  • list_faces

    The flat faces of a printable part, for picking one for a face fit-test template (make_template kind='face'): stable ids (1 = the largest; the same geometry always gets the same ids, changed geometry may renumber), outward normal and side (bottom, top, front, back, left, right), area, center, bounding box, round holes (diameter, center) and other openings; curved faces are only counted. part: which printable part (default: the only one). highlight: a face id or side; also returns a picture of the part with that face in red, to confirm the choice with the user before making the template. size: …

  • list_parts

    List the part scripts in the workspace, with the settings in effect.

  • list_versions

    The saved versions, newest first: date, id, message and the Dims values that changed. With part: numbered versions of that part (for restore_version), and what is not saved yet. On a shared (HTTP/SSH) server: the command for the user's own project folder.

Show 18 more tools
  • make_template

    A fit-test template: a quick thin print cut from the real part (same hole compensation and clearances) to check size, hole pattern and mating fits before printing the whole part. kind: 'slice' (plane XY/XZ/YZ at = Z/Y/X: the part between two planes `thickness` apart, centered on `at`), 'face' (face: an id from list_faces, a side such as 'bottom', or 'x,y,z' on it: that flat face with its holes as a plate; a side means the largest face facing that way) or 'crop' (center, size: x,y,z in mm: the part inside that box, with a thin base plate where it needs one; base=False: never). thickness: mm (de…

  • measure

    Precise measurements on the built part, in mm, with the points where they were taken: check fits with numbers instead of guessing from pictures. kind: 'distance' (a, b: piece names from build() or assembly labels, stand-ins included): the smallest gap and its two points, or when they overlap the interference volume, its box and depth. Two assembly labels are measured where assembly(d) puts them (the fit). 'wall' (at: x,y,z on or in the material; direction: optional x,y,z): the thickness along a line through the point (default: into the part along the nearest face's normal), with the gaps and w…

  • new_part

    Create parts/<name>/<name>.py from the template (Dims dataclass, build(d), VARIANTS, views, checks). name: lower_snake_case. example: copy a bundled example instead (see list_parts), e.g. 'hole_coupon' to calibrate hole compensation. Returns a short confirmation; the template is the b123d-print://template resource (or read_part), show_code=True returns the new file's code here. Usually the next step is write_part with the whole script. If you haven't, call read_guide first; confirm the dimensions with the user before writing the script.

  • params

    The part's named dimensions, read from the script without running it: each Dims field with its type, default as written, value (when the default is a literal), the comment saying where it came from, and its line; the derived values (@property) and the fields they use; and each variant's overrides in VARIANTS. Change one with set_params, not a whole rewrite.

  • read_guide

    The workflow and print rules (the b123d-print://guide resource). Call it once before the first part in a session: many clients never load that resource. essentials=True: only the short checklist of the rules most often skipped.

  • read_part

    Return the current code of a part script.

  • recipe

    Tested build123d recipes for common printable features, with printing notes and sources: teardrop holes, counterbores and countersinks, nut traps, magnet pockets, snap arms (with strain sizing), living hinges, print-in-place hinges, lids with a lip, text, bed-edge chamfers, zip-tie and cable slots, ribs and gussets. name: '' lists them; a recipe (or one of its function names) gives its code, an example and the notes. Use one before improvising the feature; part scripts import them: from b123d_print.recipes import snap_arm.

  • render_preview

    Render six views (iso, top, front, right, iso from below, bottom) as a PNG image. parts: comma-separated part names from build() (several are laid out side by side; only those are built), 'assembly' (assembled position with stand-ins), or omit: the assembly if the script has one, else every printable part side by side. One variant (default: the first). size: 'normal' or 'small' (~800 px wide, cheaper). inline=False returns only the file (over HTTP: its download link), not the image itself. Uses the pieces cached by an earlier build; fresh=True builds them again.

  • restore_version

    Bring a part (script, ref/, MEASURE.md) back to a saved version: a number from list_versions(part), or a commit id. It is saved as a NEW version, so nothing is lost: no reset, no deleted history, files added later are kept. Refused while the part has changes not saved yet (offer save_version first). Ask the user before restoring; then build_part and check. On a shared (HTTP/SSH) server: the commands for the user's project folder (version = the commit id), then write_part to put the restored script back on the server.

  • save_setup

    Save the user's first-run answers (the setup_workspace prompt): printer (a name from use_printer's search, or a nickname), material, formats ("3mf,png"), default style; hole_comp=0 records that the slicer corrects holes (the default way); a nonzero, MEASURED hole_comp / hole_comp_h is an opt-in that builds the correction into every file; calibration: other coupon results, e.g. {"clearance": 0.18, "max_bridge": 15}. With a printer, measured values are stored for it and the material. Written where use_printer writes. A value already set there is kept and listed as a conflict: ask the user, then …

  • save_version

    Save a version of the project in its version history (git, on the user's machine): each part's script, its ref/ folder, MEASURE.md and the .py files beside it, and b123d-print.toml; never out/. Only when the user said yes: after a change that built and passed its checks, OFFER "Save this version? (<part>: <what changed>)", never save on your own. message: what changed, in the user's words ("arm 115 -> 130 mm"); part: only that part (default: all). The result says what was saved and the changed Dims values. start=True first makes the project folder a git repository with a .gitignore: only after…

  • section

    Cross-section as a PNG image, each part in its own color. plane: 'XY' (at = Z height), 'XZ' (at = Y) or 'YZ' (at = X), in mm. parts: default the assembly if the script has one (shows fit and clearances), else all printable parts; or comma-separated names (only those are built). size: 'normal' or 'small' (~800 px wide). inline=False returns only the file (over HTTP: its download link), not the image itself. Uses the pieces cached by an earlier build; fresh=True builds them again.

  • set_params

    Change Dims values in the script in place, leaving every other character of the file as it was: values {"FIELD": new value, ...} replaces each field's default (only literal defaults: a default computed by an expression such as hole_comp(__file__) is refused with the reason; so are unknown fields, derived @property values and values of the wrong type). variant: change (or add) that variant's override in VARIANTS instead of the default. rebuild (default true): build before and after (the build cache makes "before" quick) and report what changed per piece: size and volume; parts: only those piece…

  • suggest_orientation

    Rank the ways to put the part on the bed, so it does not print upside down or on a thin edge: the six axis-aligned orientations and the large flat faces of its convex hull, each scored on supports (area and grams under overhangs past max_overhang, bridges apart), bed contact, height and print time (rough estimates), bridges, tip-over risk (as the check) and, with a load or the structural style, whether the load runs along the layers (DS-T1). Returns a ranked table with the Rot(x, y, z) to apply in build(d) and how. Run it before export when the part is not obviously flat-bottomed. piece: one p…

  • trace_outline

    Trace a flat object in a scan or photo (parts/<part>/ref/<file>, from upload_reference) into a 2D outline in mm for a part script: the largest object's outline and its holes, simplified to `tolerance` mm (few points: dense polylines build slowly), or with smooth=True through-points for a periodic spline. Scale, one of: dpi (a flatbed scan; omit everything to read it from the file), grid (cell size in mm of a grid or cutting mat under the object), reference ('card' = a credit card 85.60 x 53.98 mm beside the object, or 'L,S' mm of another rectangle), or points ('x1,y1,x2,y2' pixels, origin top …

  • upload_reference

    Get an original model (STL, 3MF or STEP) onto the server, into parts/<part>/ref/<filename>, to remix it, or a scan or photo (PNG, JPEG, TIFF, BMP) to trace with trace_outline (the part folder may not exist yet). With data_base64 (the whole file, base64) it is stored now, up to 50 MB; that is only practical for small files, since the model has to write out every byte. Without it, the result says how the USER copies the file: over HTTP a signed upload link for `curl -fT <file> '<link>'` (no token needed, expires), over SSH the `b123d-print push` command, locally the folder to copy it into. Then …

  • use_printer

    Optional printer profile (default is generic mode). search: find printer names ("bambu a1", "prusa mk4"). name: make it active (saved in the user's config, or over HTTP and SSH in this workspace's b123d-print.toml; "generic" clears it); a nickname given before works too. nickname: only for two printers of the same model, e.g. name='bambu_lab_p2s_0_4_nozzle', nickname='p2s-garage': each nickname keeps its own calibration. material: pla, petg, asa, abs, tpu or the user's own. Only change the printer when the user asks for it.

  • write_part

    Replace the whole part script with `code` (create the part with new_part first). The script must define build(d) (+ Dims, VARIANTS). If you haven't, call read_guide first; confirm the dimensions with the user before writing the script. Then call build_part.

Signals

Stars
1
Forks
0
Open issues
2
Weekly downloads
1,776
Last commit
Oct 23, 2026 (6 days ago)
Last release
Oct 25, 2026 (3 days ago)
Last package publish
Oct 23, 2026 (6 days ago)

From GitHub (fetched Oct 24, 2026) and the package registry.

Details

Registry name
io.github.KD5RYN/b123d-print
Version
0.3.15
Auth
No auth
Packages
pypi b123d-print
License
MIT
Repository
github.com/KD5RYN/b123d-print
Website
kd5ryn.github.io/b123d-print/
First seen
Oct 24, 2026
Last checked
Oct 26, 2026
Source
Official MCP Registrygithub-graphql
Cite this page

b123d-print MCP server. Agent Mart. https://agentmart.dev/connectors/kd5ryn-b123d-print (last updated 2026-10-26)