# Stori3D (npm · stori3d-mcp)

See and edit the building project open in Stori3D: walls, rooms, openings, finishes, skies.

- Trust score: 70/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `stori3d-mcp`: 70/100 (this document), [markdown](https://verifymcp.io/servers/richy7734-stori3d-mcp/stori3d-mcp.md), [page](https://verifymcp.io/servers/richy7734-stori3d-mcp/stori3d-mcp)

## Channel facts

- Registry: `npm`
- Package: `stori3d-mcp`
- Version: `0.9.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 30 of 93 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 6/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Licence could not be checked: the licence is shipped as a file inside the package, not declared as a standard (SPDX) licence identifier, so we cannot tell whether it is OSI-approved.
  - Actively maintained (last published 19 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 75/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 10254 tokens (~131/item across 78 items; 77 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 73/100
  - Stability observed for 22 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 77/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 32% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 6 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 79 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Stori3D MCP server?

Stori3D runs locally as an npm package, launched with npx -y stori3d-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add richy7734-stori3d-mcp -- npx -y stori3d-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "richy7734-stori3d-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "stori3d-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "richy7734-stori3d-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "stori3d-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add richy7734-stori3d-mcp -- npx -y stori3d-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "richy7734-stori3d-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "stori3d-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add richy7734-stori3d-mcp --command npx --arg -y --arg stori3d-mcp
```

### Hermes

```yaml
mcp_servers:
  richy7734-stori3d-mcp:
    command: "npx"
    args: ["-y", "stori3d-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "richy7734-stori3d-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "stori3d-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add richy7734-stori3d-mcp -t stdio -c npx -a -y stori3d-mcp
```

### Other

```json
{
  "mcpServers": {
    "richy7734-stori3d-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "stori3d-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-03 (score 70, +1)

No change was recorded against any check on this day. Stability & Change Management went from 63 to 67. That category is still filling its 30-day observation window: 19 days of observed history at the previous scan, 20 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-01 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 57 to 60. That category is still filling its 30-day observation window: 17 days of observed history at the previous scan, 18 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 50 to 53. That category is still filling its 30-day observation window: 15 days of observed history at the previous scan, 16 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-28 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-26 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40. That category is still filling its 30-day observation window: 11 days of observed history at the previous scan, 12 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-24 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-22 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-19 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (77)

### `connect` (~60 tokens)

Connect to Stori3D

Pair with the Stori3D tab showing this 6-digit code (Stori3D → AI agent → Connect). Needed once per session before the other tools work.

Input parameters:

- `code` (string, required): The 6-digit code shown in Stori3D

### `status` (~20 tokens)

Connection status

Whether Stori3D is connected, and to which project.

### `project_summary` (~81 tokens)

Project summary

Start here. The open project at a glance: levels (id, name, elevation and floor-to-floor height in mm, room count and usable room area in m²), element counts, custom property definitions, site location and sun, the active level and the selection. Units: lengths mm, areas m², angles degrees; plan x east, y north.

### `list_elements` (~326 tokens)

List elements

Elements of the model as plain data, filtered and paged. Kinds: level, wall (start/end points, length along the centre line, bulge and radius for curved walls, height, thickness, face area m², opening ids), slab, roof, stair, door, window (width, height, sill, host wall id, size limits), furniture (type, position, rotation, size, limits), room (area m², enclosed, tag), column, beam (start/end, width, depth, top), ramp (start = foot, end = top, rise, gradient), lift (position, shaft size, height, stops), parking (aisle start/end, count, accessible, bay size, angle), grid (origin, rotation, spacings, labels; not on a level), model (an imported IFC storey, SketchUp/glTF/OBJ model, or a group: source, file, position, rotation, bounds, part count, IFC classes; its parts with list_model_parts). Outlines are summarised unless detail is "full". Every element has id, kind, name, level (the level's id) and properties (custom data).

Input parameters:

- `detail` (string): full includes outlines
- `kind`: Only these kinds
- `level` (string): Level id or name
- `limit` (integer): Default 100
- `offset` (integer)
- `property` (object): Only elements with this custom property (set to this value)
- `selected` (boolean): Only what the user has selected

### `get_element` (~27 tokens)

Get element

One element by id, in full (outlines included).

Input parameters:

- `id` (string, required)

### `get_selection` (~35 tokens)

Get selection

What the user has selected in Stori3D right now — use it when they say "this wall" or "these doors".

### `get_schedule` (~129 tokens)

Get schedule

A schedule table: standard columns for the kind plus a column per custom property. openings = doors and windows (type, width, height, sill, wall); rooms (area, gross area, perimeter, enclosed); walls (length, height, thickness, face area, openings); slabs; stairs (risers, riser height, going); columns; beams; ramps (rise, gradient, transitions, headroom); lifts; parking (bays, accessible bays, bay numbers per row); furniture.

Input parameters:

- `format` (string): Default json ({ columns, rows })
- `kind` (string, required)

### `list_catalogue` (~152 tokens)

List catalogue

What can be placed: furniture types for place_furniture (with default sizes in mm, category and style), including about 180 realistic models from the asset library ("ph:…": furniture, Lighting, Decor, Office, plants and trees; ceiling and wall lamps and pictures are hung automatically), the user's My library pieces ("custom:…"), and door and window types for place_opening. The built-in pieces (no prefix) are one modern set: prefer them, and library models of style "modern" or "any", unless the user wants a period look (classic, vintage, industrial, oriental). Filter by category in your own reasoning: the list is long.

Input parameters:

- `kind` (string)

### `list_finishes` (~203 tokens)

List finishes

Finishes for paint_surface: id, name, group (Paint & plaster, Brick & block, Concrete & stone, Timber, Tiles, Flooring, Roofing, Metal & glass, Fabric, Landscape), tile (mm per pattern repeat) and source (built-in; ambientCG: photographed PBR materials, "acg:…"; or Poly Haven: photographed textures, "pht:…", e.g. oak and walnut veneers, linen, bouclé, wool, leather, render and microcement in several colours). Filter with group and/or search words (e.g. "oak", "terrazzo", "white paint"). With element instead: that element's surfaces and the finish on each (a room gives walls, floor and ceiling).

Input parameters:

- `element` (string): An element or room id: list its surfaces and their finishes instead
- `group` (string)
- `search` (string): Words to match in id, name or group

### `list_skies` (~59 tokens)

List skies

Skies for set_sky (HDRI environments: clear, cloudy, sunset, overcast, city, countryside, night, studio) with id, name and group, plus the project's current sky and its settings (null: the default lighting).

### `list_palettes` (~92 tokens)

List style palettes

Style palettes for apply_palette: matched sets of finishes (walls, floor, light and dark timber, fabric, bouclé, textiles, lamp shades, an accent, leather, stone, worktop, metal, brass, tapware, joinery, rug, pots) such as Warm modern, Scandi, Japandi, Industrial and Coastal, with the finish id in each slot and which one the project uses.

### `list_properties` (~35 tokens)

List custom properties

The project's custom property definitions (name, type text/number/boolean/choice, unit, choices, which kinds they apply to).

### `get_plan_svg` (~126 tokens)

Get plan (SVG)

The architectural 2D plan of a level as SVG text (walls cut at 1.2 m, doors and swings, dimensions in mm with chains through doors and windows, room names and areas, a north arrow). For a picture you can look at, use capture_view with mode "plan".

Input parameters:

- `level` (string): Level id or name (default: the active level)
- `scale` (number): Drawing scale denominator, default 100 (1:100); US scales too, e.g. 48 for 1/4" = 1'-0"

### `get_drawing_svg` (~222 tokens)

Get elevation or section (SVG)

An elevation (south/north/east/west: the façade seen from that side), a section (section-ew: an east–west cut looking north; section-ns: a north–south cut looking east), or a section line the user placed on the plan (section: its letter) of the whole building as SVG text: hidden-line drawing, cut walls/slabs/roofs solid, level lines with elevations. Drawing units are metres, y down. For a picture, use capture_view with mode "drawing".

Input parameters:

- `flip` (boolean): Sections: look the other way (south / west)
- `offset` (number): Sections: where to cut, mm (north for section-ew, east for section-ns). Default: through the middle
- `scale` (number): Drawing scale denominator, default 100
- `section` (string): A section line placed on the plan, by its letter (e.g. "A"); plans show them as section marks
- `view` (string): Default south; ignored with section

### `list_views` (~35 tokens)

List saved views

The project's saved camera views (id and name). Go to one with go_to_view or picture it with capture_view mode "view".

### `list_sheets` (~98 tokens)

List sheets

The drawing sheets (number, name, paper, orientation, status, revision and revisions, and each drawing on them: id, kind plan|elevation|view|schedule|note, level or view, scale, position in mm from the top left), the title block (project, practice, project number, drawn by, layout, extra fields), the notes and dimensions on drawings, and the choices: paper sizes, statuses, schedules.

### `list_comments` (~97 tokens)

Read client comments

The comments clients left on the project's review link: each thread's number (as on its pin), open or resolved, where it's pinned (plan point mm and height, level and element ids: get_element or capture_view mode "element" to see it) and its messages (who, what, when). For "summarise the client's comments" or "which ones are about the kitchen".

Input parameters:

- `status` (string): Default open

### `export_file` (~234 tokens)

Export a file

Save the project, or a drawing of it, as a file on the user's computer (Downloads unless path says where): ifc (IFC 4, for Revit, Archicad, consultants), glb, gltf, usdz (Apple AR), stl (3D printing), obj (the selection), dxf or svg (a level's plan, or drawing south|north|east|west|section-ew|section-ns; at scale, default 1:100), pdf (every sheet, one a page), xlsx (every schedule, a sheet each) or stori3d (the project file). Returns where it was saved.

Input parameters:

- `drawing` (string): dxf/svg: plan (default) or an elevation or section
- `format` (string, required)
- `level` (string): dxf/svg plans: level id or name (default the active level)
- `path` (string): Where to save: a folder or a file path (~ allowed). Default: Downloads
- `scale` (number): dxf/svg: 100 = 1:100

### `export_image` (~128 tokens)

Export an image

A presentation image (PNG) as the viewport draws it, at full size, saved on the user's computer: from the current camera, the overview or a saved view. transparent: the building alone on transparency (for brochures). For photo-real images use render_image. Returns where it was saved.

Input parameters:

- `height` (integer): Pixels, default 2000
- `path` (string)
- `transparent` (boolean)
- `view` (string): current (default), overview, or a saved view's id or name
- `width` (integer): Pixels, default 3000

### `render_image` (~171 tokens)

Render a realistic image

A path-traced (photo-real) image: glass, lamps and the sky's light, saved on the user's computer. Takes from under a minute to many minutes: samples 64 is a quick draft, 256 good (default), 1024 best; bigger images take longer. Set the sky (set_sky) and sun (set_sun) and the camera (a saved view) first. The user sees Stori3D busy meanwhile. Returns where it was saved.

Input parameters:

- `format` (string)
- `height` (integer): Pixels, default 1080
- `path` (string)
- `samples` (integer)
- `view` (string): current (default), overview, or a saved view
- `width` (integer): Pixels, default 1920

### `export_video` (~107 tokens)

Export a tour video

A walkthrough tour as an MP4 video (H.264), saved on the user's computer: about as long to make as the tour lasts. 1920 × 1080 at 30 fps by default; 1080 × 1920 for phones and Reels. Returns where it was saved.

Input parameters:

- `fps`
- `height` (integer)
- `path` (string)
- `tour` (string, required): Tour id or name
- `width` (integer)

### `list_tours` (~74 tokens)

List walkthrough tours

The project's walkthrough tours: camera paths played like a video (stops with plan positions in mm and heights above the ground in mm, travel and pause seconds, loop, where visitors may walk from, and the player-only `link` and scroll `story` link if shared), plus the project details shown with shared tours.

### `capture_view` (~281 tokens)

Look at the model

A picture, so you can check your work. mode: "overview" (the whole building from the south-east, above; site context hidden), "plan" (the 2D plan drawing of a level, north up, with dimensions), "drawing" (an elevation or section, see get_drawing_svg), "element" (one element framed), "view" (a saved view), "current" (exactly what the user sees). Look after significant changes.

Input parameters:

- `context` (boolean): Include site context (terrain, neighbouring buildings)
- `drawing` (string): For mode "drawing" (default south)
- `element` (string): Element id for mode "element"
- `height` (integer): Pixels, default 768 (plans keep their proportions)
- `level` (string): Level id or name for mode "plan"
- `mode` (string): Default current
- `offset` (number): For a section drawing: where to cut, mm
- `underlays` (boolean): Show underlays (plans or drawings the user traced over; hidden by default). Use with mode "current" or "overview" from above to read a plan you are asked to model
- `view` (string): Saved view id or name, for mode "view"
- `width` (integer): Pixels, default 1024

### `list_model_parts` (~127 tokens)

List a model's parts

The parts of an imported model (list_elements kind model): each part's id, name and, for IFC, its class (IFCWALL, IFCDOOR…), GlobalId and property sets (e.g. Pset_WallCommon FireRating). Filter by IFC class; paged. Part ids work with select and capture_view mode "element".

Input parameters:

- `id` (string, required): The model's id
- `ifcClass` (string): e.g. IFCWALL, IFCWINDOW
- `limit` (integer): Default 100
- `offset` (integer)

### `list_underlays` (~78 tokens)

List underlays

The underlays: plans and drawings (images, PDF pages, DXF linework) the user brought in to trace over, with their file, level, extent in plan (mm) and whether they show. To read one, capture_view with underlays: true (mode "current" after set_camera from above, or "overview").

### `select` (~47 tokens)

Select

Select elements in Stori3D so the user sees them highlighted and their properties (e.g. the doors that fail a check). Empty ids clears the selection.

Input parameters:

- `ids` (array, required)

### `set_camera` (~81 tokens)

Move the camera

Move the user's view: preset "overview", "top" (plan view of the active level) or "element" (frame one element), or an eye position and target (plan mm plus height in mm above ground).

Input parameters:

- `element` (string)
- `position` (object)
- `preset` (string)
- `target` (object)

### `go_to_view` (~32 tokens)

Go to a saved view

Move the user's camera to a saved view (id or name from list_views).

Input parameters:

- `view` (string, required)

### `set_active_level` (~55 tokens)

Switch level

Make a level the active one (the one being edited and drawn in plan; others show ghosted or hidden). New elements go on the active level unless you name one.

Input parameters:

- `level` (string, required): Level id or name

### `set_section` (~77 tokens)

Section cut

Cut the model to see inside: "plan" (horizontal, height mm above the active floor), "x" (vertical at plan x = offset mm), "y" (vertical at plan y = offset mm), or "off".

Input parameters:

- `height` (number)
- `mode` (string, required)
- `offset` (number)

### `set_sun` (~106 tokens)

Set the sun

Sun and shadows for the site (needs a site location: set_site): it changes the project's saved sun (not an undo step). Date YYYY-MM-DD and time in hours local to the site (e.g. 9.5 = 09:30). Returns the sun's azimuth (degrees clockwise from north) and altitude. Use with capture_view for shadow studies.

Input parameters:

- `date` (string)
- `enabled` (boolean)
- `time` (number)

### `set_site` (~146 tokens)

Set the site location

Put the project on the map: an address (looked up; the first match is used, and the matches are returned) or latitude/longitude, and north: degrees true north is turned clockwise from the plan's north (up). The map, terrain and neighbouring buildings load around it, and set_sun can then light it. Changes the project's saved site (not an undo step).

Input parameters:

- `address` (string): Street address or place, e.g. "322 King William St, Adelaide"
- `lat` (number)
- `lon` (number)
- `north` (number): Degrees clockwise from plan north (default: unchanged, 0 for a new site)

### `update_element` (~447 tokens)

Update element

Change an element. Lengths in mm, angles in degrees. By kind: level {name, elevation, height}; wall {length (along its centre line), height, thickness, type (a wall type name or null), bulge (curves it: mm its middle bows out, + to the left going start to end, 0 straight, at most half its straight length), start, end (moves its ends; walls joined there follow)}; slab {thickness}; roof {roofType flat|shed|gable|hip, pitch, overhang, thickness}; stair {width, going, maxRiser, rise, shape straight|L|U, turn left|right, winders (true: an L or U turns on tapered treads instead of a landing), position, rotation}; door/window {width, height, open 0–1, hand left|right, offset (slides it along its wall: mm from the wall's start to its centre)}, window also {sill}; model {position, rotation} (moves an imported model or group); furniture {position, rotation, width, depth, height, lamp {on, lumens, kelvin}}; column {shape rect|round, width, depth, height, position, rotation}; beam {start, end, width, depth, top}; ramp {start, end, width, rise, thickness, transition, headroom}; lift {position, rotation, width, depth, wall, height, doorWidth, doorHeight}; parking {start, end, count, accessible, bayWidth, bayLength, angle, startNumber} (moving start/end refits the count unless count is given); grid {origin, rotation, xSpacings, ySpacings, numbers, letters, extension}; room {name}. wall also {attachTop: true} to extend it up to the roof over it. Any: {name}. Fields a kind doesn't have are an error. A size outside the element's limits fails with the allowed range unless clamp is true.

Input parameters:

- `changes` (object, required)
- `clamp` (boolean)
- `id` (string, required)

### `create_walls` (~213 tokens)

Draw walls

Walls along a polyline of plan points (wall centre lines, mm). closed joins the last point back to the first. Corners join automatically. Default height 2700, thickness 200 (mm). bulges curves segments: bulges[i] is how far segment i (point i to the next) bows out at its middle, mm, + to the left going along the polyline, − to the right, 0 straight; at most half the segment's length (a half circle). type: a wall type (its layers set the thickness; the types are in the guide).

Input parameters:

- `bulges` (array): Per segment, mm; missing or 0 = straight
- `closed` (boolean)
- `height` (number)
- `level` (string): Level id or name (default: the active level)
- `points` (array, required)
- `thickness` (number)
- `type` (string): Wall type name, e.g. "Brick cavity 300"

### `split_wall` (~94 tokens)

Split a wall

Split a wall in two, offset mm from its start (along its centre line): the wall keeps the first part and its id, a new wall (returned) takes the rest with the doors and windows in it. Not through a door or window, nor within 50 mm of an end. Curved walls split into two arcs of the same circle.

Input parameters:

- `offset` (number, required)
- `wall` (string, required)

### `create_slab` (~84 tokens)

Create floor slab

A floor slab over any outline (plan points, mm; closed for you), on a level: for a terrace, a landing or a floor that isn't a room. Rooms get theirs from create_room. Default thickness 200 mm.

Input parameters:

- `level` (string)
- `name` (string)
- `outline` (array, required)
- `thickness` (number)

### `create_roof` (~206 tokens)

Create roof

A roof over a room (its id or name) or an outline (wall centre lines, mm). roofType gable (default), hip, shed or flat; pitch in degrees (default 30); overhang past the wall centre lines (default 400 mm); thickness (default 180 mm). It sits on the tallest wall of the level unless eave (mm above the level floor) says where; walls under it are cut to its slope, and attachTop on a wall (update_element) runs it up to the roof. L, T and U shaped rooms get joined roofs with valleys.

Input parameters:

- `eave` (number)
- `level` (string)
- `name` (string)
- `outline` (array)
- `overhang` (number)
- `pitch` (number)
- `roofType` (string)
- `room` (string): Room id or name (or give outline)
- `thickness` (number)

### `create_stair` (~248 tokens)

Create stair

A stair from a level up to the next: position = the foot of its first riser, at the middle of its width (plan mm); rotation = the way it climbs, degrees counter-clockwise from east (0 east, 90 north). shape straight, L (quarter turn) or U (half turn), turning left or right; winders: true turns on tapered treads instead of a landing. The riser count follows from the rise (default the level's floor-to-floor height) and maxRiser (default 180). It opens a stairwell in the slab above it. Check the footprint with capture_view mode "plan". Defaults: width 1000, going 280 mm.

Input parameters:

- `going` (number)
- `level` (string)
- `maxRiser` (number)
- `name` (string)
- `position` (object, required): Plan point in mm (x east, y north), relative to its level
- `rise` (number)
- `rotation` (number)
- `shape` (string)
- `turn` (string)
- `width` (number)
- `winders` (boolean)

### `create_room` (~147 tokens)

Create room

A room in one step: walls around the outline (wall centre lines; edges that an existing wall already covers are skipped, so rooms can share walls), a floor slab, and a room tag holding its name and custom properties. Returns the room (area = usable floor inside the walls, m²).

Input parameters:

- `height` (number): Wall height mm (default 2700)
- `level` (string)
- `name` (string)
- `outline` (array, required): Wall centre lines in order; closed for you
- `properties` (object)
- `slab` (boolean): Floor slab (default true)
- `thickness` (number): Wall thickness mm (default 200)

### `place_opening` (~195 tokens)

Place door or window

A door or window in a wall. offset = mm from the wall's start point to the opening's centre (get the wall's start/end/length from list_elements). Windows take a sill height (mm above the floor); doors stand on the floor. flip turns it to face the other side (door swing); hand puts the hinges on the right. Fails with the allowed range if it doesn't fit or overlaps another opening, unless clamp is true. Types: list_catalogue.

Input parameters:

- `clamp` (boolean)
- `flip` (boolean)
- `hand` (string): Hinges on the left (default) or right, seen from the side it opens to
- `height` (number)
- `name` (string)
- `offset` (number, required)
- `sill` (number)
- `type` (string, required)
- `wall` (string, required)
- `width` (number)

### `place_furniture` (~181 tokens)

Place furniture

A piece of furniture: type from list_catalogue, position (plan mm, its centre) and rotation in degrees counter-clockwise: 0 faces south (back to the north), 90 faces east, 180 north, 270 west. Against a wall, face away from it. Sizes in mm within its limits (fixed dimensions can't change) unless clamp is true. Leave clearances: ~900 mm walkways, 600 mm in front of storage.

Input parameters:

- `clamp` (boolean)
- `depth` (number)
- `height` (number)
- `level` (string)
- `name` (string)
- `position` (object, required): Plan point in mm (x east, y north), relative to its level
- `rotation` (number)
- `type` (string, required)
- `width` (number)

### `place_column` (~148 tokens)

Place column

A structural column standing on its level: position = centre of its foot (plan mm), shape rect (width × depth) or round (width = diameter), default 300 × 300 mm and the level's floor-to-floor height. rotation in degrees counter-clockwise. Cut solid in plans and sections.

Input parameters:

- `clamp` (boolean)
- `depth` (number)
- `height` (number)
- `level` (string)
- `name` (string)
- `position` (object, required): Plan point in mm (x east, y north), relative to its level
- `rotation` (number)
- `shape` (string)
- `width` (number)

### `place_beam` (~202 tokens)

Place beam

A horizontal beam along its centre line from start to end (plan mm), default 400 wide × 600 deep with its top just under the floor above (the level's floor-to-floor height − 200). top = height of its top above the level floor, mm. For a transfer beam carrying apartment walls over a car park, make it deeper (e.g. 600 × 1200) and run it along the walls above. Beams above the plan cut are drawn dashed in plans; cut solid in sections.

Input parameters:

- `clamp` (boolean)
- `depth` (number)
- `end` (object, required): Plan point in mm (x east, y north), relative to its level
- `level` (string)
- `name` (string)
- `start` (object, required): Plan point in mm (x east, y north), relative to its level
- `top` (number)
- `width` (number)

### `place_ramp` (~295 tokens)

Place ramp

A straight ramp rising from start (its foot, on the level floor) to end, by default rising the level's floor-to-floor height so it arrives at the floor above, which is then opened over it where headroom (default 2200 mm) would be lost. Default width 3600 (one-way car ramp; two-way ≈ 6100), slab 200 thick, with a 2000 mm half-gradient transition at each end (AS/NZS 2890.1 needs them over 1:8; pass transition 0 for none). The returned gradient is the main slope; residential car ramps up to 1:4 if 20 m or shorter, 1:5 if longer (public 1:5 / 1:6); ramps for people 1:14. To go down to a basement, place it on the lower level, foot at the bottom.

Input parameters:

- `clamp` (boolean)
- `end` (object, required): Plan point in mm (x east, y north), relative to its level
- `headroom` (number)
- `level` (string)
- `name` (string)
- `rise` (number)
- `start` (object, required): Plan point in mm (x east, y north), relative to its level
- `thickness` (number)
- `transition` (number)
- `width` (number)

### `place_lift` (~190 tokens)

Place lift

A lift shaft centred on position (plan mm), default 2000 × 2200 clear inside, 200 walls, rising from its level through every level above plus a 3600 overrun, with 900 × 2100 landing doors at each floor it reaches (they follow the levels). The floors it passes through are opened inside the shaft. rotation in degrees: at 0 the doors face south (−y).

Input parameters:

- `clamp` (boolean)
- `depth` (number)
- `doorHeight` (number)
- `doorWidth` (number)
- `height` (number)
- `level` (string)
- `name` (string)
- `position` (object, required): Plan point in mm (x east, y north), relative to its level
- `rotation` (number)
- `wall` (number)
- `width` (number)

### `place_parking` (~300 tokens)

Lay out parking bays

A row of marked car bays along an aisle line from start to end (plan mm); the bays lie to the LEFT of start → end seen from above (so start (0,0) → end (24000,0) puts them north of y = 0). As many bays as fit unless count is given. Defaults: 2400 × 5400 bays at 90° (AS/NZS 2890.1 class 1A). angle 30–90° for angled parking. accessible = how many bays at the start of the row are accessible ones, each with a 2400 hatched shared area beside it (AS/NZS 2890.6). startNumber numbers the bays. Allow a 5800 aisle (90°) between facing rows. Plans draw the lines and bay numbers; get_schedule kind parking and project_summary give the bay count.

Input parameters:

- `accessible` (integer)
- `angle` (number)
- `bayLength` (number)
- `bayWidth` (number)
- `clamp` (boolean)
- `count` (integer)
- `end` (object, required): Plan point in mm (x east, y north), relative to its level
- `level` (string)
- `name` (string)
- `start` (object, required): Plan point in mm (x east, y north), relative to its level
- `startNumber` (integer)

### `create_grid` (~260 tokens)

Add structural grid

A structural (setting-out) grid for the whole building: numbered lines 1, 2, 3… running north–south at xSpacings (mm, between consecutive lines, eastwards from origin) and lettered lines A, B, C… (no I or O) running east–west at ySpacings (northwards). origin = where lines 1 and A cross (plan mm). Every floor plan shows it with bubbles; it isn't on a level. Typical car park spans: 8400 (three 2400 bays between columns) or 7800–8100. numbers/letters override the labels. Place columns on its crossings.

Input parameters:

- `extension` (number): mm the lines run past the outer lines, default 1500
- `letters` (array)
- `name` (string)
- `numbers` (array)
- `origin` (object, required): Plan point in mm (x east, y north), relative to its level
- `rotation` (number)
- `xSpacings` (array, required): mm between consecutive numbered lines; [] for just line 1
- `ySpacings` (array, required): mm between consecutive lettered lines; [] for just line A

### `solid_operation` (~143 tokens)

Solid tools (booleans)

Boolean on closed objects, by id (elements or other objects): union (merge), subtract (the first minus the others, which are removed), trim (the same, the others kept) or intersect (only the overlap). The first id is kept and becomes a plain mesh (it loses parametric data, so walls, slabs, roofs, stairs and columns can only cut, not be cut). A door or window used to cut cuts its rough opening and stays, e.g. to open an imported wall. Objects that aren't closed solids are refused. Returns the result's id.

Input parameters:

- `ids` (array, required): The first is kept
- `operation` (string, required)

### `paint_surface` (~255 tokens)

Paint surfaces

Put a finish (list_finishes) on surfaces of one or more elements, as one undo step. surface by kind: room — walls (every wall face inside the room), floor (its floor slab), ceiling (the underside of the slab above); wall — left, right (seen walking from its start to its end) or both; slab — top or underside; roof — roofing or gables; stair — flights or rails; column, furniture, door, window — all, or a part name (list_finishes with element lists them). Default: a room's walls, a wall's both sides, a slab's top, otherwise all. A wall face is one surface along its whole length: painting one room's walls also colours that face where the wall continues past the room. Asset library models ("ph:…") keep their own materials. scale multiplies the tile size (2 = pattern twice as big); rotation turns the pattern (90 for boards or tiles running the other way).

Input parameters:

- `finish` (string, required): Finish id from list_finishes
- `ids` (required): Element or room id(s)
- `rotation` (number): Degrees
- `scale` (number)
- `surface` (string)

### `set_sky` (~180 tokens)

Set the sky

The project's sky (list_skies): an HDRI environment that lights the model with realistic reflections and ambient light and can show behind it. id "none" goes back to the default lighting. rotation (degrees) turns it, e.g. to put the sunset behind the building; intensity is the lighting strength (1 = as photographed, 0–5); background false lights the model without showing the sky; blur (0–1) softens the background. Settings you leave out keep their current values. Saved with the project; one undo step. Works alongside set_sun (direct sunlight and shadows).

Input parameters:

- `background` (boolean)
- `blur` (number)
- `id` (string): Sky id, or "none"; omit to adjust the current sky
- `intensity` (number)
- `rotation` (number)

### `apply_palette` (~173 tokens)

Apply a style palette

Recolour every built-in piece by role in one step with a style palette (list_palettes): upholstery, timber, stone, metal, lamp shades and so on each take the palette's finish; screens, bulbs, plants, books, people and cars keep theirs, as do asset-library models. walls and floors also paint every room's walls and floor slab. The project keeps the palette, so pieces placed afterwards come in it. One undo step. Repaint single surfaces afterwards with paint_surface.

Input parameters:

- `floors` (boolean): Also paint every room's floor (default false)
- `palette` (string, required): Palette id, e.g. "warm_modern", "scandi", "japandi", "industrial", "coastal"
- `walls` (boolean): Also paint every room's walls (default false)

### `save_view` (~42 tokens)

Save the current view

Save the user's current camera as a named view (for presenting, image exports and share links). Set it up first with set_camera.

Input parameters:

- `name` (string, required)

### `create_tour` (~285 tokens)

Create walkthrough tour

A walkthrough tour, the way architects draw it: a `path` of points on the plan (mm, x east, y north) that the camera travels through along a smooth curve, at each point's camera `height` above its level's floor and `speed` (m/s) to the next point, pausing where `pause` is set. The camera looks along the path, or turns to a point's `lookAt` near it. Keep paths inside rooms and through door openings (not through walls): a point a metre outside the front door, one just inside, then the middle of each main room; pause 1–2 s where there is something to see. For an opening shot, start with an aerial point (height 15000+, speed 4–8). Alternatively `stops`: saved views or eye/target cameras with travel/hold seconds. `walk`: let visitors walk around from a spot on a floor. Check with list_tours and capture_view.

Input parameters:

- `fov` (number): Field of view for path tours, degrees (default 60)
- `loop` (boolean)
- `name` (string)
- `path` (array): The camera path (preferred)
- `stops` (array): Instead of a path: camera stops
- `walk` (object): Let visitors walk around from here

### `update_tour` (~100 tokens)

Update walkthrough tour

Change a tour (id or name): name, loop, fov, walk (null: no walking), path (replaces all points; same format as create_tour) or stops.

Input parameters:

- `fov` (number)
- `loop` (boolean)
- `name` (string)
- `path` (array)
- `stops` (array)
- `tour` (string, required): Tour id or name
- `walk`

### `delete_tour` (~30 tokens)

Delete walkthrough tour

Delete a tour (id or name). Its share link stops working.

Input parameters:

- `tour` (string, required)

### `share_tour` (~157 tokens)

Share walkthrough tour

Publish a tour as a player-only link (play/pause/speed, optional walking, project details; nothing else) and return it. With `story: true` it is shared as a scroll story instead: a page that opens on the floor plan and, as the visitor scrolls, raises the walls, comes down to where the tour starts and walks it, each room turning from a drawing to its materials as the camera goes in. A tour can have both links. The user is asked to allow it first, and the project must be signed in to the cloud. The link updates on every cloud save. Set the project details with set_project_details first.

Input parameters:

- `story` (boolean)
- `tour` (string, required)

### `import_file` (~242 tokens)

Import a file

Bring a file from the user's computer into the project. Models: IFC (from Revit, Archicad; each storey becomes a model on its level), SketchUp as COLLADA .dae or a 3D Warehouse .zip (components kept), glTF/GLB, OBJ, FBX, STL; units are guessed unless given. Underlays to trace over: an image, a PDF page (scale: the drawing's scale, e.g. 100 for 1:100; or width in mm) or a DXF (units; its own if it says). Without a known scale the user is asked to calibrate it. Up to 22 MB.

Input parameters:

- `as` (string): Default auto: images, PDFs and DXF are underlays
- `page` (integer): PDF page (default 1)
- `path` (string, required): The file on the user's computer (~ allowed)
- `scale` (number): Underlay drawn at 1:scale (PDFs)
- `units` (string): A model's or DXF's drawing units
- `width` (number): Underlay's real width, mm

### `create_sheet` (~118 tokens)

Create a sheet

A drawing sheet with the title block, numbered after the last (A-101, A-102…) unless number is given. Then place_drawing puts plans, elevations, sections, saved views, schedules and notes on it, and export_file format pdf prints them all.

Input parameters:

- `name` (string): e.g. "Ground floor plan"
- `number` (string)
- `orientation` (string)
- `paper` (string): Default A3
- `status` (string): e.g. Preliminary, For planning, For construction

### `place_drawing` (~204 tokens)

Place a drawing on a sheet

Put a drawing on a sheet (id, number or name) where there's clear room, at the largest usual scale that fits unless scale is given: kind plan (level), elevation or section (view south|north|east|west|section-ew|section-ns), view (a saved view's picture), schedule (view = openings|rooms|walls|slabs|stairs|columns|beams|ramps|lifts|parking|furniture) or note (text). x, y: its centre, mm from the sheet's top left.

Input parameters:

- `kind` (string, required)
- `level` (string)
- `scale` (number): 100 = 1:100
- `sheet` (string, required)
- `text` (string): For a note
- `title` (string): Its caption (default: what it shows)
- `view` (string)
- `x` (number)
- `y` (number)

### `update_sheet` (~123 tokens)

Update a sheet

Change a sheet: name, number, paper, orientation, status; revise with a note to issue the next revision (P1 → P2, A → B) dated today; removeDrawing (a drawing's id) takes a drawing off it.

Input parameters:

- `name` (string)
- `number` (string)
- `orientation` (string)
- `paper` (string)
- `removeDrawing` (string)
- `revise` (string): What changed, for the revision table
- `sheet` (string, required)
- `status` (string)

### `remove_sheet` (~37 tokens)

Delete a sheet

Delete a sheet and the drawings placed on it (the model and the notes on drawings stay). Undoable.

Input parameters:

- `sheet` (string, required)

### `set_title_block` (~117 tokens)

Set the title block

The title block every sheet shares: project, practice, projectNumber, drawnBy, layout (corner, strip down the right side, or band along the bottom) and fields, the practice's own boxes (label and value, e.g. Checked, Client ref). The client and site come from set_project_details.

Input parameters:

- `drawnBy` (string)
- `fields` (array)
- `layout` (string)
- `practice` (string)
- `project` (string)
- `projectNumber` (string)

### `add_drawing_note` (~228 tokens)

Annotate a drawing

A note, leader, element tag or dimension on a drawing: drawing plan (a level's plan: level) or south|north|east|west|section-ew|section-ns. Positions are plan points in mm with height above the level floor (mm, default 0): at (where text goes), tip (what a leader or tag points at; element: the tagged element's id), points (2 or more, for a dimension string measured along the line through the first two; offset: how far to its side, mm, default 600). size: text height on paper, mm (2.5, 3.5 default, 5, 7). They show on the sheets and exports.

Input parameters:

- `at` (object)
- `drawing` (string, required)
- `element` (string)
- `kind` (string, required)
- `level` (string)
- `offset` (number)
- `points` (array)
- `size` (number)
- `text` (string)
- `tip` (object)

### `remove_drawing_note` (~40 tokens)

Remove an annotation

Remove a note, leader, tag or dimension from a drawing (its id from list_sheets). Undoable.

Input parameters:

- `id` (string, required)

### `share_link` (~101 tokens)

Share the project

Publish the project as a link anyone can open in a browser (no account): view-only, or a review link with comments: true, where clients pin comments on the model (list_comments reads them). The user is asked first; the project must be in the cloud (signed in), and review links need a plan with them. The link updates on every cloud save. Returns the link.

Input parameters:

- `comments` (boolean): Let visitors pin comments (default false)

### `stop_sharing` (~64 tokens)

Stop sharing

Take a link down, so it stops working: the project's link (default), or a tour's link or scroll story (tour, story). The user is asked first. Comments already made are kept.

Input parameters:

- `story` (boolean)
- `tour` (string)

### `reply_comment` (~78 tokens)

Answer a client comment

Answer a comment thread on the review link (its id or number from list_comments), as the signed-in user: the client sees it on the link. The user sees your answer and allows it first. resolve: true also marks it resolved.

Input parameters:

- `resolve` (boolean)
- `text` (string, required)
- `thread` (string, required)

### `resolve_comment` (~44 tokens)

Resolve a client comment

Mark a comment thread on the review link resolved (or open again with resolved: false). Clients see it.

Input parameters:

- `resolved` (boolean)
- `thread` (string, required)

### `set_project_details` (~63 tokens)

Set project details

The details shown with shared tours: architect, client, location, description (plain text). Levels and floor area are added automatically.

Input parameters:

- `architect` (string)
- `client` (string)
- `description` (string)
- `location` (string)

### `create_level` (~50 tokens)

Add level

An empty level on top of the building (or below it). height = floor to floor, mm.

Input parameters:

- `below` (boolean)
- `height` (number)
- `name` (string)

### `copy_level` (~52 tokens)

Copy level above

Copy a level (walls, doors, windows, slabs, furniture, room tags) to a new level on top of the building — the quick way to start the next storey.

Input parameters:

- `level` (string, required)

### `remove_elements` (~56 tokens)

Delete elements

Delete elements by id (a wall takes its doors and windows with it). Deleting a level, or more than 10 elements, asks the user in Stori3D first — tell them why.

Input parameters:

- `ids` (array, required)

### `set_properties` (~62 tokens)

Set custom properties

Set custom property values on an element (null clears one). Values are checked against the project's definitions (types, choices). Setting data on an untagged room tags it and returns its new id.

Input parameters:

- `id` (string, required)
- `values` (object, required)

### `define_property` (~90 tokens)

Define custom property

Add or replace a project property definition: name, type (text, number, boolean, choice), optional unit, choices (for choice), kinds (which element kinds get it; omit for all).

Input parameters:

- `choices` (array)
- `description` (string)
- `kinds` (array)
- `name` (string, required)
- `type` (string, required)
- `unit` (string)

### `remove_property` (~27 tokens)

Remove custom property

Remove a property definition (values already on elements are kept).

Input parameters:

- `name` (string, required)

### `batch` (~153 tokens)

Batch of changes

Several changes as ONE undo step, all or nothing: if any operation fails, none are applied and the error says which. Each operation is { tool, args } using update_element, create_walls, create_room, place_opening, place_furniture, place_column, place_beam, place_ramp, place_lift, place_parking, create_grid, paint_surface, apply_palette, set_sky, save_view, create_level, copy_level, set_properties, define_property or remove_property. Use it for multi-step edits the user would think of as one change.

Input parameters:

- `label` (string): Short name for the undo step, e.g. "Furnish bedroom"
- `operations` (array, required)

### `undo` (~34 tokens)

Undo

Undo your own last change (only if the latest step in Stori3D's history is an AI change — never the user's).

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/richy7734-stori3d-mcp/stori3d-mcp#diagnostics

## Score history

- 2026-11-05: 70
- 2026-11-04: 70
- 2026-11-03: 70
- 2026-11-02: 69
- 2026-11-01: 69
- 2026-10-31: 68
- 2026-10-30: 68
- 2026-10-29: 67
- 2026-10-28: 67
- 2026-10-27: 66
- 2026-10-26: 66
- 2026-10-25: 65
- 2026-10-24: 65
- 2026-10-23: 64
- 2026-10-22: 64
- 2026-10-21: 63
- 2026-10-20: 63
- 2026-10-19: 63
- 2026-10-18: 62
- 2026-10-17: 62
- 2026-10-16: 61
- 2026-10-15: 61
- 2026-10-14: 61
- 2026-10-13: 31
- 2026-10-12: 31
- 2026-10-11: 31
- 2026-10-07: 16

## Common questions

### What is the Stori3D MCP server?

Stori3D is an MCP server listed in the public MCP registry as io.github.richy7734/stori3d-mcp. See and edit the building project open in Stori3D: walls, rooms, openings, finishes, skies. This page covers its npm package (stori3d-mcp).

### Is the Stori3D MCP server safe to use?

Stori3D scores 70 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Stori3D MCP server expose?

Stori3D exposes 77 tools: connect, status, project_summary, list_elements, get_element, and 72 more. Their descriptions and schemas cost roughly 10,099 tokens of context every time the server is loaded.

### Is the Stori3D MCP server still maintained?

Stori3D is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the Stori3D MCP server?

VerifyMCP ran 14 checks on Stori3D, covering Malware scan, Known CVEs, Install scripts, Dependency health and 10 more. 2 items could not be completed, a gap on our side rather than a finding about Stori3D: License and Security disclosure. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/stori3d-mcp
- Socket report: https://socket.dev/npm/package/stori3d-mcp
- Website: https://stori3d.com/mcp
- Changelog RSS feed: https://verifymcp.io/servers/richy7734-stori3d-mcp/stori3d-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/richy7734-stori3d-mcp/stori3d-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/richy7734-stori3d-mcp/stori3d-mcp.json
- HTML version of this page: https://verifymcp.io/servers/richy7734-stori3d-mcp/stori3d-mcp