millwork-mcp-lite
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
Cabinet-shop calculator for frameless (European-style) casework. Typical flow: review_cabinet_schedule -> build_cutlist -> count_sheets or nest_sheets -> calculate_edgeband. All dimensions are inches. Every tool is read-only and deterministic: it computes from the job you pass in and never writes files or contacts a machine. Use list_cabinet_types first if you are unsure how to describe a cabinet.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
| prompts | {
"listChanged": false
} |
| resources | {
"subscribe": false,
"listChanged": false
} |
| experimental | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| review_cabinet_scheduleA | Check a cabinet schedule for mistakes before anything is calculated or cut. Use this first on any schedule read from drawings or typed by a person. It does not build parts; use build_cutlist for that (build_cutlist also runs this review and refuses to continue on errors). Checks: duplicate tags, unknown cabinet types, non-positive sizes, widths outside 9-48", single doors wider than 24", drawer bases with no drawers, shelves in sink bases, unusual base heights (not 30-36") and deep wall cabinets (over 16"). Returns: {job_number, ok (true when there are no errors), errors (count), warnings (count), issues: [{level: "error"|"warning", cabinet: tag, message}]}. Errors block the cut list; warnings need a person to confirm. Example: {"job": {"job_number": "K-101", "cabinets": [{"tag": "B1", "type": "base", "width": 36, "height": 34.5, "depth": 24, "doors": 1}]}} -> ok=true with one warning that the single door would be about 36" wide. |
| build_cutlistA | Turn a cabinet schedule into a part-by-part cut list for frameless cabinets. Use when someone needs the parts to cut, a parts count, or square footage per material. For sheet counts use count_sheets; for sheet layouts use nest_sheets; for edgebanding length use calculate_edgeband. Construction (generic defaults): full-height sides; bottom between the sides; two 4" top rails on base, drawer_base and sink_base, a full top on wall and tall; adjustable shelves 1/16" narrower than the opening and 1" plus the back thickness shallower than the box; an applied back, full width x full height; full-overlay doors and drawer fronts with a 1/16" reveal. Runs review_cabinet_schedule first and returns {error, review} instead of parts if the schedule has errors. Returns: {job_number, summary: {total_pieces, by_material: {code: {pieces, square_feet}}}, parts: [{cabinet, name, material, length, width, qty, edgeband ("front"|"all"|""), notes}], review}. length is the long/grain direction; all sizes are finished inches. Example: a 24" base with 1 door and 1 shelf gives 2 sides 34.5x24, a bottom 22.5x24, 2 top rails 22.5x4, a shelf 22.4375x22.75, a back 34.5x24 and a door 34.375x23.875. |
| nest_sheetsA | Lay out one material's parts on full sheets for a panel saw and report the cutting plan. Use when someone needs the actual sheet layouts (which part goes where). For just the number of sheets across every material, count_sheets is faster. The layout is strip-cut and guillotine-safe: each sheet is ripped into strips across its width, then parts are crosscut from each strip. Parts keep their listed grain direction (length runs along the sheet). 1/4" is trimmed off each sheet edge. Not for CNC routers. Parameters: material is a material code from the job (defaults to case_material); sheet_length and sheet_width in inches (default 96 x 48); kerf is the saw blade width in inches (default 0.125). Returns: {job_number, material, sheet_size, sheets_needed, parts_nested, overall_yield_pct, oversize_parts: [parts too big for the sheet], sheets: [{sheet, yield_pct, strips: [{rip_width, y, parts: [{cabinet, name, length, width, x}]}]}]}. x and y are inches from the sheet's corner. Example: {"job": {...}, "material": "MEL-WHT-34", "sheet_length": 97, "sheet_width": 49}. |
| count_sheetsA | Count how many full sheets each material in the job needs (quick material takeoff). Use for bids and ordering ("how many sheets of melamine do I need?"). It runs the same panel-saw nesting as nest_sheets for every material but returns only the totals; call nest_sheets when someone needs the layouts. Returns: {job_number, sheet_size, materials: {code: {sheets, yield_pct, oversize_parts}}}. oversize_parts counts parts that do not fit the sheet and need a bigger sheet or a joint. Example: the bundled sample kitchen (8 cabinets) returns 9 sheets of 3/4" case material and 3 sheets of 1/4" back on 48 x 96 sheets. |
| calculate_edgebandA | Calculate the linear feet of edgebanding a job needs, per material, with a waste allowance. Use when ordering edgeband rolls or pricing edgebanding. For sheet goods use count_sheets; for the individual parts and which edges they get, use build_cutlist (its edgeband field drives this total). Counted edges: the front edge of sides, bottoms, tops, top rails and adjustable shelves ('front'), and all four edges of doors and drawer fronts ('all'). Backs get no edgebanding. Edgeband is grouped by the part's material code, so doors in front_material are totalled separately from case parts. Parameters: waste_pct is the extra percentage added for trimming and machine setup, 0-50 (default 10). Behaviour: read-only and deterministic. Runs review_cabinet_schedule first and returns {error, review} instead of totals if the schedule has errors. Returns: {job_number, waste_pct, by_material: {code: {linear_feet, with_waste_linear_feet}}, total_with_waste_linear_feet}. Feet are rounded to 0.1. Example: one 30" x 30" x 12" wall cabinet with one door and waste_pct=0 gives 19.7 linear feet of the case material (sides, bottom and top front edges plus the door perimeter). |
| list_cabinet_typesA | Reference for building a job: the cabinet types this server understands, with typical sizes and which fields each uses. Use before calling the other tools when you are turning drawings or a description into a schedule and are unsure which type or size to use. Takes no input. Returns: {units, types: {type: {description, typical: {width, height, depth}, uses}}, defaults: {construction rules and thicknesses}, example_job}. |
| get_server_infoA | What millwork-mcp-lite does, its license, and what the full millwork-mcp adds (CNC router nesting, woodWOP DXF output, 32mm joinery, grain matching, estimating, inventory). Use when someone asks what this server can do, or needs something outside the lite tools. Takes no input. Returns: {name, license, tools, typical_flow, full_version, full_version_adds, contact}. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
| plan_cabinet_job | Walk an AI through turning a cabinet description into a reviewed cut list and material order. |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
| Sample kitchen job | An 8-cabinet frameless kitchen schedule to try every tool with. |
| Construction defaults | The generic frameless construction rules the cut list uses. |
TDQS
Scored across 7 tools
Each tool targets a distinct step in the cabinet job workflow, and the descriptions explicitly steer callers between near-siblings (count_sheets vs nest_sheets, build_cutlist vs review_cabinet_schedule). The only soft overlaps are that count_sheets is a totals-only subset of nest_sheets and build_cutlist internally re-runs review, but both are called out in the text, so misselection risk is low.
All seven tools use the same snake_case verb_noun pattern (get_server_info, list_cabinet_types, nest_sheets, count_sheets, review_cabinet_schedule, build_cutlist, calculate_edgeband). The only nit is 'cutlist' vs 'cut_list', which is a trivial spelling choice, not a convention break.
Seven tools is a tight, well-scoped surface for a lite millwork helper: reference, validation, cut list, sheet counts, sheet layouts, and edgebanding. Every tool maps to a concrete step a user would actually ask for, with no filler.
The surface covers the full estimating-to-cut-list lifecycle: discover types, validate schedule, build parts, count sheets, nest layouts, and total edgeband. Gaps are mainly output/export (no CSV/PDF cut list writer) and costing/inventory, which are explicitly deferred to the full millwork-mcp, so agents can still work around them.