Describes the environment variables required to run the server.

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

SketchFlow is a live vector sketch board the user draws on with mouse, stylus or finger while you watch and draw too.

• Start with open_board, then look to see what is there (it returns an image plus board size, layers and drawing space).

• When the user wants to show you an idea, call wait_for_sketch (they press Send on the board).

• Coordinates are board pixels, origin top-left. Lines whose endpoints share exact coordinates are joined (joints) and move together.

• drawing_space sets isometric, 1/2/3-point perspective, 3-view or 4-view layouts; draw along those directions.

• Dimensions are parametric: edit_items set_dimension changes geometry to match.

• For "make this move like this": build links with draw (shared endpoints = pin joints), then mechanism with pins + a motor, simulate to check the joint paths, and play to show the user.

• Everything you do is undoable by the user (board undo).

3D PARAMETRIC MODEL (open_model, model_build, model_describe, model_view, model_session, model_export) — a separate page at /3d/ with 4 linked views (TOP | 3D / FRONT | RIGHT). Units mm. Z is up, X right, -Y towards the viewer (front). Every object is a shape + its own parameters in its own local frame; its place comes from a mate to another object's connector (or a fixed pose). The world origin is ephemeral: by default the bottom of the ground object (the first one); "origin" can move it. All positions you send/receive are measured from it. Shapes (op add, type + params): box {width,depth,height} (base-centred, sits on z=0), wedge {width,depth,height} (slope falls toward +x), cylinder {diameter,height}, cone {diameter,top,height} (top 0 = point), sphere {diameter}, fillet {size,length,style:fillet|weld|chamfer} (an edge strip you place yourself). Features: extrude {profile:[[x,y],...], arcs:[{i, c:[x,y], ccw}] (segment i is an arc around centre c), splines:[{i, pts:[[x,y]…]}] (segment i is a smooth curve through those points), length, end:'blind'|'symmetric'|'through' (through all: for cuts), draft (taper °, inward), thin (wall thickness: a closed profile becomes a wall; with open:true an open polyline becomes a rib / thin plate), twist (deg), scale (end size ratio), direction [x,y,z]} — or a parametric sketch shape instead of a profile: shape:'rect' {x, y, width, height, radius (corner)} | 'circle' {x, y, diameter} | 'slot' {x, y, width (overall), height} | 'polygon' {x, y, diameter, sides}; those sizes stay editable dimensions (link them, put them in configurations). An extrude with into + mode:'subtract' is a cut / pocket; polyline profiles (extrude / revolve / loft) take sketch constraints: constraints:[{type:'h'|'v', i}, {type:'length', i, p:'d1'}, {type:'radius', i (an arc segment), p}, {type:'parallel'|'perpendicular'|'equal' (lines' lengths or arcs' radii)|'angle'|'tangent' (two segments that meet, line–arc or arc–arc)|'concentric' (two arcs), i, j}, {type:'fix', i, at:[x,y]}, {type:'fixx'|'fixy', i}] (segment i runs point i → i+1; arc centres are solved too); or {op:'constrain', id, type, i, j?, value?} adds one (valued ones become parameters d1, d2… = editable dimensions) and {op:'unconstrain', id, index} removes one; model_describe reports degrees of freedom left; loft {profile, profile2 (same or different point count), length, twist}; revolve {profile:[[r,z],...], degrees} around the object's local Z; sweep {profile, path:[[x,y,z],...]} or helix:{radius, pitch, turns, left} instead of path; {op:'helix', wire, radius, pitch, turns, left} is a coil spring. face:{obj,conn} starts the feature on that face and keeps it attached; to put a profile anywhere on a face (any angle), mate it: mate:{to, a:, b:'start'} (join, flip true) or b:'end', flip:false (cut), slide:[u,v] = where on the face. Reference planes: {op:'plane', target, face | at+normal, offset (gap along the normal), tilt (° about the face's u axis), angle} — mate parts or sketches to its 'plane' connector; {op:'split', target, plane: | {obj, conn}, keep:'below'|'above'|'both'} cuts a part with it ('above' = the side its normal points to; both = two parts). Any mate also takes tilt (°). Threads (modelled, ISO metric coarse M2…M24): add type bolt {size, length, head:'hex'|'socket', thread_length} (connectors bottom = tip, seat = under the head, top), type nut {size | size:'custom' + diameter + pitch, shape:'hex'|'round'|'knurled', thickness, od}, a threaded cylinder {op:'thread', target:, size, length, from:'bottom'|'top'} (or cylinder params thread, pitch, thread_length, thread_from, bore for a tube), and holes kind:'tapped' + modelled:true for real internal threads. Curved faces: {op:'wrap', target, at:[x,y,z] + normal (a point on the round face) | angle (°) + height (from the middle, on a cylinder part), profile [[s,t]…] (s round the face, t along it, from that point; arcs / splines too) or shape or text + size, depth, mode:'emboss'|'engrave'} wraps a sketch or text round a cylindrical face (any round face is found by fitting); on a cylinder part the wrap follows its diameter. Connectors (mate targets): box: top, bottom, front (-y), back, left (-x), right, center, corners corner±x±y±z (e.g. corner-x-y-z = bottom-left-front), edge midpoints edge:top-front, edge:bottom-left, edge:front-right … (wedge: slope instead of top/right, no edge:). Round shapes: bottom, top (cone: apex), center, side+x, side-x, side+y, side-y. Fillet strip: edge, leg-x, leg-z, end-a, end-b. Features: start, end, center, top, bottom, bbox+x/-x/+y/-y/+z/-z. Every other flat face of a shape is a face connector too, named face: (e.g. face:side2 — an extrude's side 2, an inclined face of a loft, a flat ring of a revolve), so holes, text, bosses, cuts, sketches and mates work on inclined and side faces. Planes: plane, back, center. World: origin, xy, xz, yz. model_describe connectors_of gives positions + normals; model_query what:'faces' lists every face of a part with its connector name, normal, centre and area. Mate: {op:'mate', id, to, a: target connector, b: own connector, offset (gap along the target connector's outward normal; negative = sink in), slide:[u,v] (move along the target face, along its u and v axes; on a top face u=+x, v=+y — connectors_of lists u and v for every connector), angle (spin about the normal, deg), flip}. Face-to-face mates flip automatically so faces touch. "add" accepts mate:{to,a,b,...} inline; with no mate and no "at" a new object sits on top of the ground object. Booleans: add with into:"targetId" + mode:"subtract"|"add"|"intersect" (or op boolean {target, tool, mode}); tools stay editable parametric objects (separate undoes it). A through-hole = {op:'add', type:'cylinder', params:{diameter:8, height: thickness+2}, mate:{to:'plate', a:'top', b:'top', flip:false, offset:1, slide:[x,y]}, into:'plate', mode:'subtract'} (its top sits 1 mm above the plate top and it reaches 1 mm below the bottom, so it cuts clean through). Edges: {op:'edge', target, near:[x,y,z] (a point on the edge), style:'fillet'|'weld'|'chamfer', size}. The edge is found on the finished body; convex (outside) edges are trimmed, concave (inside corner) edges are filled — automatically, by the angle between the faces (override with mode add/subtract). Round edges (a flat face meeting a cylinder/cone/revolve: disc rims, hole rims, boss bases) are treated all the way round — e.g. chamfer a hole rim = countersink, fillet a boss base = filled. The edge is remembered by the two surfaces it lies between, so it is re-found after parameter changes. Configurations (size variants): {op:'config', action:'add', name:'Large', vars:{len:200}, suppress:[ids]} saves a table of variable values (and features to switch off); {op:'config', name:'Large'} switches (name null = Default); action 'set' / 'delete' / 'rename'. Drive sizes with variables (=#len) so configurations can change them. Instances: {op:'instance', of: partId, mate|at} is a linked copy — edit the original and every instance follows; the parts list counts them. (op 'duplicate' makes an independent copy.) Holes: {op:'hole', target, at:[x,y,z] (a point on a face), size:'M2'…'M16', kind:'simple'|'counterbore'|'countersink'|'tapped'|'insert' (heat-set), fit:'close'|'normal'|'loose'|'print' (FDM, +0.2), through (default) or depth, dims:true (default: driving dimensions from the two nearest edges)} — ISO 273 clearance, ISO 4762 counterbores, ISO 10642 countersinks, tap drills; through holes stay through when the part changes. Pattern a hole to repeat it. Boss / cut on a face: {op:'feature', target, face:'top' (or at:[x,y,z] + normal), shape:'cylinder'|'box'|'cone'|'wedge'|'sphere', params:{diameter,height}|{width,depth,height}, mode:'boss'|'cut', slide:[u,v], angle} — a boss is a boolean add standing on the face, a cut a pocket of that depth sunk flush into it; both are mated to the face at that point, so they follow it when the part changes. For any other outline, extrude a profile with mate:{to, a:, b:'start'} (boss) or b:'end', flip:false (cut), plus into + mode. Text: {op:'text', target, face:'top' (or at:[x,y,z] + normal from a click), text, height (cap height, mm), depth, mode:'emboss'|'engrave', path:'line'|'arc'|'arc-inside'|'points', radius (arc baseline radius, about the anchor), angle (deg, turns the whole text about its anchor), align:'center'|'start'|'end', points:[[x,y],…] (path in the face plane, mm), weight (stroke, default 0.12 × height), spacing (letter gap in font units), slide:[u,v] on the face} — emboss is a boolean add standing on the face, engrave a boolean remove cut in flush with it; 'arc' reads clockwise over the top with letter tops outward, 'arc-inside' reads along the bottom with tops toward the centre; edit the words or any size later with set. Built-in single-stroke engraving font: A–Z (lower case prints as capitals), 0–9 and . , : ; - _ + = / \ ( ) [ ] # ! ? ' " ° % * & < > @ Ø ± ×; flat faces only (no wrapping onto curved faces). Without target it is a stand-alone text part. Shell: {op:'shell', target, thickness, open:<one of the part's face connectors, e.g. top | end>|'none'} hollows any closed part to even walls (an inward offset of every face, mitred at corners, not a scale), including booleans, edge-rounded parts and imported meshes; a rounding smaller than the wall gets a sharp inner corner and a boss or rib thinner than two walls stays solid (a warning says which); a cut that leaves a section thinner than two walls is an error naming it. Section view: model_view section:{axis:'x'|'y'|'z', offset, flip}. History: {op:'suppress', id, on} keeps a feature but turns it off; {op:'rollback', to: index | id | null} shows the model as it was (new features are inserted at the bar); {op:'move', id, to | before | after} reorders (tools stay after what they cut); {op:'duplicate', id} copies a part with its holes and edges. Other ops: set {id, params, name, color, at, rot, hidden, fixed}; delete {id}; ground {id}; origin {obj, conn}; fix {id} (freeze current place, drop mate); cleanup {fixFloating} (repairs orphans: tools or edges whose target is gone, mates to deleted objects, dimensions whose ends are gone); rename {name}. Reference & queries: model_reference (no topic: every op in one line; topic: full text + a worked example — read it before using an op for the first time) and model_query (faces with their connector names, edges, measure, section areas, bounding boxes) — use them instead of guessing. Checks: model_check finds overlapping parts (interference) and, with motion:{id}, sweeps a joint and reports the first contact; the Motion drawer stops at contact and turns colliding parts red. Joints & motion: a mate can move. {op:'joint', id, joint:'revolute' (spins about the mate axis — its value is the mate angle) | 'slider' (axis 'n' along the mate normal, or 'u'/'v' across the face — value "travel") | 'cylindrical' (angle + offset) | 'planar' (u, v, angle) | 'screw' (turns about the mate axis and advances pitch mm per turn — a nut on a bolt, a cap on a threaded neck; pitch comes from the thread when omitted, negative for left-hand) | 'fixed', limits:{angle:[lo,hi], travel:[lo,hi], …}}. {op:'drive', values:{id:{angle:30}}} moves joints (clamped to limits). Gears meshed by a gear mate turn with their partner automatically (continuous, at the ratio). model_view joints:{id: value} shows a pose without changing the model. Gear-meshed gears cannot be joints themselves — make the gear that drives them revolute. Links (leader/follower) & formulas: any numeric param — and a mate's offset, angle, tilt and slide values — can be "=formula" instead of a number — "=plate.depth" (follow another part's size), "=plate.depth - 2#wall", "=max(a.width, b.width)"; references are objectId.param (or Object_Name.param), #variables, pi; functions min max round floor ceil abs sqrt sin cos tan (degrees). Followers update whenever a leader changes; typing a plain number unlinks. {op:'var', name:'wall', value: 3 or "=formula"} sets a model variable (value null removes it). {op:'link', id, param, to:{obj, param}, factor, offset} is a shorthand. Dimensions: {op:'dim', a:{obj,conn}, b:{obj,conn}, view:'top'|'front'|'right', axis?} measures between connectors in that view; axis 'normal' = square to a face/edge seen edge-on (hole centre → plate face = the usual off-edge dimension; chosen automatically when one end is such a face), 'h' / 'v' = horizontal / vertical in the view, 'aligned' = straight line. {op:'setdim', id, value} makes it DRIVING: the part that hangs off the other (by its mate) moves so the distance is value, and it is held there after every later change (value null makes it a reference again). {op:'dimaxis', id, axis}; undim {id}. model_describe lists dimensions with their values. Every object's own parameters are shown as editable dimensions in the 2D views; the user can click one to change it, and mates keep everything attached. Warnings list floating (unmated, not fixed) and orphaned objects — fix them or tell the user. Patterns (arrays): {op:'pattern', of: id or [ids], kind:'linear' (count, spacing, direction:[x,y,z], optional count2/spacing2/direction2 for a grid) | 'circular' (count, angle total°, about:{obj, conn} e.g. {obj:'disc', conn:'center'} for a bolt circle) | 'mirror' (plane:'yz'|'xz'|'xy' through the origin, or about:{obj, conn} = that face's plane)}. Copies are live (they follow the original's sizes and boolean role); a hole's countersink comes along. Revolve is the op 'revolve' (a profile around an axis); circular pattern repeats features around one. Welds vs fillets — manufacturing logic: a WELD joins two parts that are made separately; they stay separate parts (an assembly) and can be pulled apart. {op:'weld', a, b, near:[x,y,z] (optional: the seam nearest this point; default the longest), size (leg mm), profile:'flat'|'convex'|'concave', all_around:true (every inside seam between them)}. The parts must touch (mate them first); the bead is its own body (material defaults to part a's). A FILLET/CHAMFER blends ONE part: to fillet where two parts meet, first union them ({op:'boolean', target, tool, mode:'add'}) — they are then one piece (cast, printed or machined together). Metadata & mass: every part can carry meta {material, density (g/cm³, overrides the material), fill (0–1, e.g. 0.2 for 20% infill), part_no, supplier, notes, quantity}; shorthand material:'aluminium' on add/set; {op:'material', material} sets the model default. model_mass gives mass, centre of gravity, inertia per part and for the assembly, whether it stands, and the parts list. Materials: pla, petg, abs, asa, tpu, nylon, pa_cf, pom, acrylic, polycarbonate, resin, tough_resin, aluminium, steel, stainless, cast_iron, brass, bronze, copper, titanium, oak, pine, plywood, mdf, carbon_fibre, concrete, glass, rubber. Add-ons: model_addon lists them. Built-in "gears": shape type 'gear' {module, teeth, width, bore, pressure_angle, style:'spur'|'helical'|'herringbone', helix (° — sign = hand; mating external gears need opposite signs), backlash (mm), clearance (×module), shift, internal (ring gear), rim}; mate kind 'gear' keeps two gears in mesh: {op:'mate', id, to, kind:'gear', around (direction °, world), axial, phase} — centre distance and tooth phase follow the live sizes. Actions: advise {ratio, process: fdm|sla|cnc|laser|injection|hobbed, priority: balanced|strength|quiet|compact|precision, torque N·m, rpm, material, centre_distance, build} (picks module, teeth with a hunting-tooth ratio, form, pressure angle, backlash, clearance, width and explains why), pair {teeth:[z1,z2], module, process, around, driver, ring}, train {teeth:[…] simple chain | stages:[[z1,z2],[z3,z4]] compound}, planetary {sun, planet, planets}, gear {teeth, module, process}. Ask the advisor first when the user names a purpose or a process. Welding & joining (built-in add-on "welding"): give two parts that touch — {addon:'welding', action:'advise', args:{a, b, near?, method:'auto'|'weld'|'bond'|'braze'|'filled'|'tab', process:'auto'|'135'|'136'|'141'|'131'|'111'|'121', labor_rate}} finds the joint (butt, tee, corner, lap; thicknesses; seam length; per side: inside corner or flush, torch access and what blocks it, ISO 6947 position) and returns light / regular / heavy suggestions: joint and edge prep (square, V, X, Y, bevel, K, J, U; root face, gap, backing, back gouge), process and filler, sizes, passes, weld metal, time (fit-up, prep / machining, preheat, welding, finishing / grinding, inspection), cost, ease 1–5, ISO 5817 level, NDT, the ISO 2553 symbol and the reasons. Materials decide the method (aluminium to steel, plastics, wood → bonded; copper alloys → brazed; composites → filled and tabbed). action:'apply' with duty builds it in one undoable step: cuts the prep out of the parts, opens the gap, places the weld metal / adhesive / filler / laminate as parts attached to a, and a weld-symbol callout (on drawings too). model_reference topic "welding" has the details. Start: open_model tells you what is open — a fresh page holds the bracket demo, or it is the user's own model. For something new, start clean with model_session action:"new" (name it); never build into the user's model unless they asked. Workflow: open_model → model_build (one batch per idea, with a clear label, look:true when it helps) → model_view to check → adjust with set/mate. Errors name the valid connectors/objects; the whole batch is rolled back on any error.

Features and capabilities supported by this server

Functions exposed to the LLM to take actions

Interactive templates invoked by user choice

Contextual data attached and managed by the client