LLM + RAG Floorplan Generator (Grasshopper C# STEP_00–STEP_09)

WICKERSON STUDIOS — Floorplan LLM + RAG Generator (Grasshopper C# STEP_00–STEP_09)

README.txt (vFP_RAG1.0)

1) What this is

This product is a STEP-based Grasshopper C# node pipeline that uses:

• LLM prompting (image + text) to derive structured plan intent + parameters

• RAG (Retrieval-Augmented Generation) to “ground” new unit layouts in a library

 of real plan archetypes (your own plan images + metadata)

• Deterministic geometry assembly to output:

 - unit boundary + room polygons

 - doors + windows

 - fixtures (kitchen/bath/closet/laundry)

 - annotations + dimension text in 3D (Rhino TextEntity / Annotation)

 - slab + wall solids and optional opening booleans

 - a final export package: JSON + TXT report + optional 3DM

The pipeline is designed for apartment unit floorplans inspired by real-world

marketing plans (e.g., luxury apartment plan sheets), and is meant to be driven

by the prompts and plan references you paste into STEP_01b.

2) What you get

A complete 10-node Grasshopper “Node Editor” script series:

STEP_00 — INIT / EngineState / CFG+SFG canonicalization

STEP_01b — LLM (OpenAI Responses API) + optional RAG library generation output

STEP_02 — Program + Room intent parsing (targets / room list / labels)

STEP_03 — Base unit plan synthesis (unit boundary + room curves)

STEP_04 — Doors + windows generation (curves + tags)

STEP_05 — Fixtures generator (kitchen, bath, closet, laundry) — curve assemblies

STEP_06 — RAG selection + blending (choose best PlanDoc(s), apply biases)

STEP_07 — 3D text + dimension annotation (fast + scalable) for Rhino display

STEP_08 — Solids (slab + walls) + optional boolean opening cuts (performance caps)

STEP_09 — Final packaging + export (JSON/TXT + optional 3DM with layers)

Each STEP reads STATE_IN and outputs STATE_OUT so the entire pipeline is a

single “stateful machine” that is easy to extend and debug.

3) Intended workflow (high-level)

A) Paste your Master CFG + Master SFG into STEP_00 and Run=true

B) In STEP_01b, paste:

  • your OpenAI API key

  • your ArchitecturePrompt (text)

  • your ReferenceImageUrl (plan image or inspiration image URL)

  • (optional) plan metadata snippets

  STEP_01b returns:

  • CFG overrides (param changes)

  • SFG overrides (structured guidance channels)

  • (recommended extension) RAG_JSON_OUT for downstream ranking

C) STEP_02–STEP_06 generate an apartment unit plan from:

  • the targets in CFG (beds/baths/sqft)

  • the “style/program” guidance in SFG

  • the retrieved PlanDoc(s) from RAG

D) STEP_07 adds professional annotations + dimensions (scaled parametrically)

E) STEP_08 generates slab + walls and optionally cuts openings

F) STEP_09 exports a deliverable package:

  • UnitPlan_*.json (full payload)

  • UnitPlan_*.txt (human readable report)

  • UnitPlan_*.3dm (optional) layered geometry for sharing

4) Requirements

• Rhino 8 + Grasshopper

• C# Script component / Node Editor (GH Script)

• Internet access (only for STEP_01b if you enable LLM calls)

• An OpenAI API key (STEP_01b)

Notes:

• STEP_01b is built on the OpenAI “Responses API” endpoint. If you swap models,

 keep the JSON-schema strict output logic intact.

• The scripts are designed to degrade gracefully: if the API call fails, the

 pipeline uses deterministic fallbacks (seeded) so you still get geometry.

5) Master CFG (recommended baseline)

Use this as your STEP_00 “Master CFG” starting point (US feet + apartment tuned):

brand=Wickerson Studios

project=Woodside-Style Apartment Floorplan RAG Generator — vFP_RAG1.0

cta=https://www.wickersonstudios.com

units=ft

6) Master SFG (recommended baseline)

Use this as a “stable” Master SFG (STEP_00 input). STEP_01b can append/replace.

reference: Woodside-style luxury apartment plan set (Kansas City) — open living core, efficient circulation, large windows.

program: 1–3 bedroom apartment unit with modern open kitchen + island; bedrooms buffered from living; strong storage + laundry.

style: clean, contemporary, marketing-plan clarity; orthogonal geometry; clear labels; consistent dimension logic.

massing: rectilinear unit footprint; living/dining as primary daylight zone; bedrooms on quieter wing; baths near bedrooms; closets inboard.

facade: window-biased living and primary bedrooms; optional bay-window feel; avoid deep dark interior cores.

math: grid-aligned partitions; adjacency weights; area targets; RAG blending between archetypes; seeded variation for diversity.

notes: prioritize readable plans; stable booleans; cap openings/walls for performance; generate annotations scaled for Rhino viewports.

7) STEP-by-STEP overview (what each node does)

STEP_00 — INIT

• Parses cfg/sfg, normalizes keys, applies defaults.

• Creates EngineState JSON (STATE_OUT) with opts/sel/ai/logs/stats.

STEP_01b — LLM + RAG

• Sends prompt text + optional plan image URL to OpenAI Responses API.

• Returns strict JSON schema for:

 - cfg overrides (k/v pairs)

 - sfg overrides (reference/program/style/massing/facade/math/notes)

• Recommended extension: RAG_JSON_OUT:

 - a JSON array of PlanDoc derived from your plan images + metadata text.

STEP_02 — Program intent

• Creates room list + room type names/targets from:

 - cfg targets (beds/baths/sqft)

 - sfg channels

 - optional RAG docs

STEP_03 — Unit plan synthesis

• Builds UnitBoundary + RoomCurves (closed curves).

• Establishes consistent BasePlane and room indexing.

STEP_04 — Doors + windows

• Converts adjacency and “exterior wall” detection into:

 - DoorCurves (lines or rectangles)

 - WindowCurves (lines or rectangles)

• Adds tags/metadata for downstream cutters and annotations.

STEP_05 — Fixtures

• Generates fixture curves inside appropriate room types:

 - kitchen: cabinet run(s) + optional island

 - bath: vanity + shower/tub + toilet

 - closet: shelving run

 - laundry: W/D pair rectangle

• Outputs fixture curves + planar breps + tags.

STEP_06 — RAG rank + blend

• Scores candidate PlanDoc records against target constraints.

• Selects top-k + blends weights to influence room program + proportions.

STEP_07 — Annotations + dimensions

• Adds professional 3D text tags for:

 - rooms, doors, windows, fixtures

• Adds dimension strings/lines with strong caps for speed.

• Uses cfg scales:

 - roomTextScale, fixtureTextScale, dimTextScale

STEP_08 — Solids + openings

• Extrudes slab and walls.

• Converts DoorCurves/WindowCurves into opening cutter breps.

• Optionally boolean-differences openings (heavy step) with caps:

 - maxWalls, maxOpenings, booleanBatch, timeBudgetSec

STEP_09 — Final export

• Computes metrics (areas, counts), produces package JSON + TXT report.

• Optional: writes .3dm with layers for sharing.

8) Performance tips (avoid crashes)

If STEP_08 gets slow or crashes:

1) Set CutOpenings=false (preview walls/solids first)

2) Reduce maxWalls and maxOpenings (e.g., 280→180; 140→80)

3) Reduce booleanBatch (8→4)

4) Reduce timeBudgetSec (8→4)

5) Prefer orthogonal polylines for RoomCurves and UnitBoundary

9) Safety + API key handling

• Do not bake your API key into the definition.

• Provide it via a Grasshopper panel/param and keep the file private.

• STEP_01b is designed so the pipeline still works with no key (fallback mode).

10) License / usage (suggested)

This is a parametric workflow tool. You may use outputs in your design work and

visualizations. Do not redistribute the scripts as-is.

Support / Updates

Wickerson Studios

https://www.wickersonstudios.com