OwlCAD

Ask, in plain language, how to achieve something in OwlCAD and get a prose answer grounded ONLY in the product documentation, with the ids of the help articles it drew on. Use this when you need to know which tool or parameter does a thing — "how do I make a hole an M3 bolt passes through", "what does the clearance modifier do" — rather than guessing at a tool call. It answers from the docs and says so when they do not cover something, so an empty answer is information, not a failure. It changes NOTHING: no project is read or written. Requires a Pro plan and the ask scope, and it draws on the SAME small daily allowance as the in-app assistant, so prefer the schema resources for anything they already answer.

Find which parts physically overlap, and by how much volume. This is the assembly check you cannot do by reasoning about a tree OR by looking at a render — an interference is usually hidden inside the model. Run it on anything with more than one part that is meant to fit together.

Get a URL to PUT a local file to, so import_model and import_2d can take it WITHOUT the bytes passing through your context — base64 costs roughly 380,000 tokens per megabyte and most clients cannot produce it at all. PUT the file to uploadUrl with the headers given, then call the importer with ticketId. If you cannot PUT, give the person handoffUrl and they upload it in their browser; poll the importer until it stops answering awaiting_upload. Note the TWO expiries: uploadUrl dies in minutes, the ticket lasts a day — pass ticketId back here for a fresh URL rather than starting over.

Permanently delete one of your projects and its geometry. Irreversible — there is no trash. Deleting a project you did not create is not possible.

Apply edit ops to a node tree you pass IN, and get the edited tree back. Nothing is saved and no project is touched — this is the unsaved counterpart to edit_project. Use it to change a model you are still working on without re-sending the whole tree every time: add a node, cut a hole, group parts, wrap a modifier, then feed the result straight to evaluate, print_check or export. Target nodes by their id; a node you send keeps the id you gave it, and one you omit an id for gets one back in the result, so a later call can name it. Unlike edit_project this is FORGIVING: an op that cannot be applied is skipped and reported in skipped rather than failing the whole call, because nothing here is written and a nearly-right tree beats none; what your nodes lost the same way is in treeWarnings. Same ops as edit_project — read owlcad://schema/edit-ops for what each op requires (this tool’s ops carry no schema of their own), and owlcad://schema/primitives for the node vocabulary an addNode carries.

Make a TARGETED change to one of your projects — change a parameter, move a node, add or remove one, group nodes into a boolean, create or set a variable, switch configuration. Prefer this over update_project when you are changing an existing model: it needs only the ids you are touching, not the whole tree, and it does not strand mates the way a wholesale replacement does. Read with get_project authored: true first — those are the ids this accepts. Every op must apply or the whole call is refused and nothing is written. It can also restructure: dissolve a boolean, unwrap a modifier, or turn a selection into a reusable component you place again with addInstance — which is how you build an assembly without paying for every copy against the node cap. owlcad://schema/edit-ops lists what every op requires; the schema below is a flat bag of every field any op takes.

Run a model through the real CSG kernel and report whether it BUILDS: watertight, triangle count, bounding size in mm. Call this before exporting — an empty result usually means boolean operands did not overlap the way you expected. Its warning is only a bounding-box sanity check (a sub-mm feature, or bigger than a typical bed); it does NOT look at overhangs or wall thickness, so a clean evaluate does not mean the part prints — run print_check for that, and measure for material. A node or op in your nodes that could not be built as sent is dropped or changed and named in treeWarnings — fix it and call again.

Evaluate a model and return it as base64 bytes in STL, 3MF or OBJ. 3MF comes back CARVED — one object per top-level part, named from the scene tree and carrying its colour, so a slicer can arrange and recolour them separately; the result lists the names in objects. STL is one fused mesh (the format has no object concept). For STEP use export_step — it is B-rep, takes minutes, and runs as a job.

Flatten the model to 2D as DXF or SVG, for a laser, vinyl cutter or CNC. The default "silhouette" projects it onto the view plane; "section" cuts through it — how to check an internal wall or bore no render shows.

Export a SAVED project as STEP — real B-rep, not a mesh, for CAD interchange. OCCT takes minutes, so this runs as a JOB: call with projectId to get a jobId, then call again with that jobId alone until status is "done", waiting retryAfterMs between polls (polling faster burns your call budget). A poll reports waitingMs; a job still "queued" after a few minutes is stuck, so stop polling and start a new one. Needs a saved project — run save_project first; it cannot export an inline tree. Pro accounts only.

Load one of the authenticated account’s projects and list its nodes with their current parameters — for inspecting or describing an existing model. Reports any variables, components, configurations and mates the project carries beyond its nodes. Pass authored: true before you intend to CHANGE it.

Import a DXF as a new project, extruded into solid geometry. Unlike a mesh import this stays PARAMETRIC — every closed outline becomes an extrude node whose profile and height you can then edit, so a drawing someone sent you becomes a model you can change. The response reports what the file declared its units to be, and names any entity types it contains that were not read.

Import an STL, OBJ or 3MF file as a new project — for geometry you did not author. STL and OBJ carry no unit, so pass unit if you know it; otherwise it is guessed and the guess is reported back so you can correct it. The response reports whether the mesh is watertight and what is wrong with it if not — a mesh that is not watertight cannot take part in a boolean, so check this before building on it.

Report on a job handle you were given. A slow analysis on a SAVED project (evaluate, print_check, measure, check_interference) is finished in the background instead of failing, and answers with a jobId; call this with that id until status is "done", waiting retryAfterMs between polls. The result is exactly what the original tool would have returned. STEP jobs are polled with export_step, not here.

List folders you own or belong to, as { folders: [{ folderId, name, role }] }. Pass a folderId to organize_project.

The parts OwlCAD ships — brackets, fasteners, spacers, board and motor reference bodies, mechanism pieces. Each is PARAMETRIC and datasheet-dimensioned, so a Raspberry Pi reference body has the real footprint and hole pattern. Insert one with an edit_project addPart op. Reach for this before hand-modelling something that sounds standard.

The authenticated account’s projects, most recently updated first — how to find an id for get_project.

Exact volume, surface area, centre of mass and connected-body count, plus an estimate of the filament a print would consume and what it would cost. Use it to answer "how heavy / how much material / how much filament / how much will this cost" — nothing else reports those, and they cannot be derived from a bounding box. Also checks a model is ONE body — two bodies where you expected one means operands that never touched.

Return { url }, the editor link for a project you own. It opens only for that account; to hand a model to anyone else, use share_project.

Move one of your projects into a folder, or out of one. Folders are how a shared workspace is organized — a project filed into one inherits that folder’s members. Call with no folderId to take it out again. Use list_folders to see which folders you can file into.

Analyse a model for 3D-printing problems: overhang area beyond the safe angle, and the thinnest wall. Use this before calling a part done — it is the check you cannot do by reasoning about the tree, and evaluate does not answer it. If the request mentions supports, overhangs, thin walls, or whether a part fits the bed or will print at all, this tool is the only thing that answers it.

Reads an owlcad:// resource as a tool result, for clients that do not let you read MCP resources — any owlcad:// URI these tools tell you to read works here. owlcad://schema/primitives without keys is an index; pass keys for the full parameter ranges of the entries you will use.

Fork a PUBLIC project into a new one you own, keeping the lineage link back to the original. This is how you start from someone else’s published model instead of from nothing. Only public projects can be remixed; to copy one of your own, read it and save the tree as a new project.

Render the model to PNG images you can actually look at, from one or more named views. Use this to CHECK your work — a tree that evaluates cleanly can still be the wrong shape, and this is the only way to notice. Flat-shaded diagnostic render, not a marketing shot.

Find every imported mesh in one of your projects that is not watertight, and weld cracks, close holes and fix face directions. A non-watertight mesh cannot take part in a boolean — the evaluator degrades it to nothing — so a model built on one comes back missing a part with no error anywhere. Run this when a project contains an import and the geometry is not behaving. Pass dryRun to see what is broken without changing it.

Save a model as a project on the authenticated account, returning its id. Pair with open_in_editor to hand a person an editable link — that is usually a better deliverable than a bare mesh file. Each call creates a new project.

Turn on (or off) public link sharing for one of your projects and return the link. This is usually the deliverable a person actually wants: open_in_editor’s link only works for the account that owns the project, so it is useless for handing to someone else. A shared link opens read-only — the viewer cannot change your model. Anyone holding the link can open it, so only share what you mean to.

Cut one body in a project into two halves at a plane, replacing it, with a joint so they go back together after printing; the reply lists the new bodies. This is the answer to "my model is too big for my printer". Both halves stay fully parametric — each is the original body intersected with a half-space, not a flattened mesh — so they still export as solids and still open for editing. Pick the joint by what the print needs: dowel puts a socket in BOTH halves and prints the pin separately, so neither half has anything standing off its cut face and a wrong fit costs a two-gram reprint instead of a whole half; pin and tenon grow the key out of one half; bolt is the only one that comes apart again. Omit position to cut through the middle of the body on that axis.

Replace the geometry of one of your existing projects, keeping its id, link and history. Pass the version you got from get_project — if the project has changed since, the update is refused rather than silently overwriting that change. Use this instead of save_project when iterating, so a person keeps one link.