Garden Design MCP Server
This MCP server lets an AI assistant design and edit a real garden in the Zaprojektuj-Ogrod.pl browser editor, with changes visible live in 2D/3D.
Locate a plot worldwide, import Polish land-registry parcels and buildings, set boundaries, and use OSM/satellite/survey map backgrounds.
Work with reference photos and survey plans: upload/attach images, zoom into details, lay maps to scale, and convert map points to garden coordinates.
Add context pins for doors, windows, gates, and views; inspect site analysis for facades, garden depths, neighbours, and trees.
Create, update, and delete zones for functional areas, planting, paths, terraces, buildings, parking, and other garden spaces.
Search products and plants by attributes, get plant details, place plants at mature size, plant zones, suggest species, and swap generic shapes for real plants.
Add, update, and delete garden objects such as plants, architecture, ground surfaces, and paths.
Analyze zones and objects for density, coverage, overlaps, and boundary issues; capture previews and review the design in 2D or 3D.
Build the designer’s house from photos using simple blocks, roofs, walls, openings, and preview images.
Maintain a design journal/description, undo/redo actions, save changes, export/import state, clear scenes, and check connection/version.
Use MCP resources and prompts for garden metadata, zones, pins, objects, coordinate-system docs, and guided design workflows.
Allows using OpenStreetMap as a map background under the garden, helping locate and visualize the plot against real-world maps.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Garden Design MCP Server Help me design my garden step by step."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Garden Design MCP Server
Let your AI assistant design a garden on your real plot. This MCP (Model Context Protocol) server connects Claude Code, Claude Desktop, Cursor or any other MCP client to the Zaprojektuj-Ogrod.pl Garden Editor, a browser app for garden and landscape design in 2D and 3D. You watch every change appear in the editor as the assistant makes it, then walk through the finished garden in 3D.
Step-by-step setup guide: in English · po polsku
What the assistant can do
Find the plot anywhere in the world, on OpenStreetMap or a satellite photo. In Poland it imports the exact parcel boundary and the buildings from the land registry (Geoportal, ULDK).
Read your photos and floor plan to put the doors, windows and views on the right walls of the house.
Draw what is already there: fences, paving, the driveway, a heat pump on the wall. Nothing that exists is moved without asking.
Lay out zones for your wishes at practical sizes (a terrace for six, a path, raised beds, a bench corner), and say so when a wish does not fit instead of shrinking it quietly.
Choose plants from a catalog of 2,000+ by sun, soil, hardiness and size, and place them at their mature spread. Surfaces, furniture, raised beds and planters come from the same catalog.
Check its own work: planting density per bed, previews of the plan, 2D and 3D views. It saves the design to your account.
It works one step at a time and stops for your sign-off: the site first, then the zones, then the planting.
Related MCP server: Civil 3D MCP Server
Quick start
1. Add the server to your AI client. No install is needed: npx downloads and runs it.
Claude Code (~/.claude.json):
{
"mcpServers": {
"garden-editor": {
"command": "npx",
"args": ["@zaprojektujogrod/mcp-server"]
}
}
}Claude Desktop (Settings → Developer → MCP Servers):
{
"garden-editor": {
"command": "npx",
"args": ["@zaprojektujogrod/mcp-server"]
}
}2. Open a garden in the Garden Editor at zaprojektuj-ogrod.pl and switch the MCP connection on in Settings › AI assistant. The editor connects to the server on your computer.
3. Ask your assistant, for example: "Help me design my garden, step by step." Or start from the server's start_design prompt.
Effort. Medium effort is enough. In our tests Claude Opus 5.5 designed as well at medium effort as at high, for about a quarter less. Effort is your client's setting, so the server can't set it. In Claude Code, start with claude --effort medium.
How it works
┌─────────────────┐ stdio ┌──────────────────┐ WebSocket ┌──────────────────┐
│ AI client │ ◄────────────► │ MCP server │ ◄──────────────► │ Garden Editor │
│ (Claude, etc.) │ │ (this package) │ localhost:3333 │ (your browser) │
└─────────────────┘ └──────────────────┘ └──────────────────┘The server runs on your computer and talks to the editor open in your browser over a local WebSocket (ws://localhost:3333). Your garden stays in your account; the assistant runs in your own AI client, on your own subscription or API key.
Setup from source
If you prefer to run from source instead of npx:
git clone https://github.com/zaprojektuj-ogrod/garden-design-mcp.git
cd garden-design-mcp
npm install
npm run buildThen configure your AI client with a direct path:
{
"mcpServers": {
"garden-editor": {
"command": "node",
"args": ["/path/to/garden-design-mcp/dist/index.js"]
}
}
}Available tools (56)
Tools follow the design funnel: Site → Context → Zones → Detailing → Review. Tools that create or change things take a list (add_objects, update_objects, delete_objects, add_pins, add_zones), one item or many. Call get_design_guide once at the start: it holds the whole workflow, the photo method and the planting rules.
Replies are compact JSON, with numbers rounded and fields the assistant never uses left out, because every reply is re-read on each later turn. A batch answers with ids in input order (null where one failed) and issues for failures and warnings.
Another 17 tools still answer when called but aren't listed, since every listed tool's definition rides along with each request:
the one-item twins of the batch tools:
add_object,add_zone,add_pin,update_object,delete_object;undo,redo,clear_all,export_state,import_state;set_units,get_view_mode,get_layer_visibility,get_coordinate_system,get_zone_types;connection_status,get_version.
Phase 1: Site
Tool | Description |
| Find a place anywhere in the world from an address |
| Place the garden on the map at real-world coordinates |
| Get the garden's place |
| Show or hide a map under the garden: OpenStreetMap, the satellite photo (Poland) or a laid survey map |
| Give the plot boundary as a polygon in metres (from measurements or traced from the map) |
| Land registry parcel by WGS84 lat/lon (Poland) |
| Land registry parcel by parcel ID (Poland) |
| Address ( |
| Import a parcel as the garden boundary, with the cadastral map behind it (Poland) |
| Import the buildings on and around the parcel from the land registry (Poland) |
| House facades by compass side, party walls and the garden depth on each side; the site's main directions for zone edges ( |
| Upload a reference photo (kept for the session) |
| Get the uploaded reference photos |
| Hand the editor a picture from a file on the designer's computer (a survey map, a site plan, a drawing): kept as an attached image for |
| A close-up of an image attached in the editor's chat or handed over with |
| Lay a survey map or site plan to scale under the garden, from two matched points or two points and a distance |
| Turn points on the laid survey map into garden coordinates in metres |
Phase 2: Context
Tool | Description |
| Add context pins (door, window, gate, view), one or many |
| Delete a pin by ID |
| Get all pins |
| Get garden metadata (name, rotation, boundary, stats) |
| Set north orientation in degrees |
| Read the assistant's design journal: its working memory of the garden between sessions, kept with the garden and never shown to the owner |
| Write the journal whole, or with |
| Write the garden's description when the owner asks for it or agrees: the design as it stands now, in Markdown, shown with the garden on the website |
| Capture a top-down view as an image the assistant sees inline: 800 px by default; |
Phase 3: Zones
Tool | Description |
| Add zones (polygon or path in metres), one or many; each answers with area, narrowest width and overlaps |
| Update zone properties |
| Delete a zone by ID |
| Get all zones |
| List objects whose centers fall inside a zone |
| Density and cover of a zone: planting cover counted once where plants and shapes overlap, the cover of each height layer (ground, shrub, tree), objects by category |
Phase 4: Detailing
Tool | Description |
| Search the product catalog by layer and name and/or |
| Filter plants by kind (tree, shrub, perennial, grass…), sun, soil, hardiness, flower color, height, spread, bloom time, plus an optional name query; each match gives its mature height and spread |
| The valid filter values for |
| A plant's characteristics, requirements, maintenance level and spacing; |
| Top-level categories for a layer |
| Leaf categories under a parent category |
| Full product details by ID |
| Get all garden objects (filter by layer; |
| Add plants, architecture, ground surfaces or generic plant shapes, one or many ( |
| Plant zones with the plants or generic plant shapes the assistant chose: the editor places them in groups of 3–7 in beds, in one row in a screen, a hedge shape as a line along its zone, clear of paths, terraces, lawn and the plants of their own height layer already there (ground cover goes under shrubs and trees), and reports each zone's cover, counted once and per layer |
| The species that fit generic plant shapes — their habit and size, the place's light, soil and hardiness, species a shape's label names first; shapes nothing fits listed apart |
| Swap shapes for species in place, each at its own catalog size (a hedge as a row, ground cover as one species or a mix); one undo brings the shapes back |
| Update objects (position, size, rotation, product; a shape's size within its form's range), one or many |
| Delete objects by ID, one or many |
Phase 5: Review
Tool | Description |
| Snapshot of the scene; |
| Switch between 2D and 3D view |
| Show/hide a layer |
| Focus the camera on an area |
| Save all changes to the account |
The designer's own house
Built from the designer's photos, step by step, out of simple blocks, on the house's land-registry outline (after import_buildings). Kept with the garden as its description and rebuilt wherever the garden opens; no model file is stored.
Tool | Description |
| The main block on the house's outline, at true size and turn, its front on the compass side given; |
| A block's roof: gable, hip, mono-pitch, flat, or none (a post); ridge direction, heights, covering, colour; chimneys, solar panels |
| Walls' finish and colour, a lower band, the plinth |
| One facade's windows, doors and facade panels |
| Add, change or remove a further block: a wing, a garage; posts and open roofs for a porch, a carport, a pergola |
| Pictures of the house from the sides asked for, to compare with the photos |
| The house as built: position, facades by compass side, blocks, openings |
Utility
Tool | Description |
| The full design guide: workflow, photo method, zone sizes, journal and description, plant selection |
capture_preview: what the assistant sees
capture_preview returns an MCP ImageContent block ({type: "image", data, mimeType: "image/jpeg"}). The connected assistant sees it directly and can describe and check the plan without any file on disk.
It does not write a file to disk. MCP clients (Claude Desktop, Claude Code, Cursor, …) show the image inline, and the server does not keep screenshots. To keep the JPEG, right-click → "Save image as…" on the image in your client, or read the base64 in content[0].data from your own client harness.
MCP resources
URI | Description |
| Garden metadata |
| All zones as JSON |
| All context pins |
| All garden objects |
| Coordinate system documentation |
MCP prompts
Prompt | Description |
| Begin a new garden design, as the editor's guided set-up does: the site first, then zones and planting, each signed off |
| Resume an existing garden (assess state, suggest next steps) |
| Review and optimize the zone layout within the boundary |
Development
Run in development mode (with hot reload):
npm run devThe server logs to stderr so it does not interfere with MCP stdio communication.
Po polsku
Serwer MCP do projektowania ogrodów z asystentem AI. Łączy Claude, Cursor lub inny klient MCP z edytorem Zaprojektuj-Ogrod.pl. Asystent znajduje działkę (w Polsce z granicami i budynkami z Geoportalu), rysuje to, co już na niej jest, układa strefy według Twoich życzeń i dobiera rośliny z katalogu, a Ty widzisz projekt ogrodu w 2D i 3D. Instrukcja: Konfiguracja serwera MCP.
License
MIT, see LICENSE. Questions and bug reports: zaprojektuj-ogrod.pl/kontakt.
Available Tools
63 toolsadd_objectA
Add a garden object (plant, building, or ground shape). Type determines rendering: 'plant' for plants, 'building' for architecture, 'rectangle'/'ellipse'/'polygon'/'path' for ground shapes. For type='path', provide pathWaypoints (centerline) and pathWidth; the outline polygon is computed automatically. Supply productId OR productQuery (name search resolved server-side). Width/height are optional — if omitted, defaults from the product catalog are used.
Inputs: type (required), x, y, path, +12 more.
add_objectsA
Add multiple garden objects in a single call. Returns array of results. Use this instead of calling add_object multiple times. Each object supports productId OR productQuery, and optional width/height.
Inputs: objects (required).
add_pinA
Add a context pin to the garden. Returns the pin ID.
Available pin types: • door — main entrance door (red) • patio_door — patio/garden door (teal) • window — window opening (blue) • gate — garden gate/entrance (green) • view_good — desirable view direction (yellow) • view_bad — undesirable view to screen (grey)
Inputs: x (required), y (required), pinType (required), label, +1 more.
add_pinsA
Add multiple context pins in a single call. Returns array of pin IDs. Use this instead of calling add_pin multiple times.
Available pin types: • door — main entrance door (red) • patio_door — patio/garden door (teal) • window — window opening (blue) • gate — garden gate/entrance (green) • view_good — desirable view direction (yellow) • view_bad — undesirable view to screen (grey)
Inputs: pins (required).
add_zoneB
Add a new zone to the garden. Returns the zone ID.
Available zone types (type → default height → category): • entry — 0.3m — functional (entrance area) • relaxation — 0.5m — functional (seating, lounging) • activity — 0.3m — functional (play, sports) • utility — 0.4m — functional (compost, storage, bins) • wild — 0.6m — functional (naturalistic area) • tall_plants — 2.0m — planting (trees, large shrubs) • privacy_screen — 1.8m — planting (hedges, screening) • low_plants — 0.5m — planting (perennials, groundcover) • herbs — 0.3m — planting (herb garden) • lawn — 0.05m — planting (grass area) • path — 0.05m — infrastructure (walkways) • building — 3.0m — infrastructure (structures) • terrace — 0.2m — infrastructure (paved patio) • parking — 0.05m — infrastructure (driveway, car space)
Inputs: zoneType (required), x, y, path, +8 more.
add_zonesA
Add multiple zones in a single call. Returns array of zone IDs. Use this instead of calling add_zone multiple times.
Available zone types (type → default height → category): • entry — 0.3m — functional (entrance area) • relaxation — 0.5m — functional (seating, lounging) • activity — 0.3m — functional (play, sports) • utility — 0.4m — functional (compost, storage, bins) • wild — 0.6m — functional (naturalistic area) • tall_plants — 2.0m — planting (trees, large shrubs) • privacy_screen — 1.8m — planting (hedges, screening) • low_plants — 0.5m — planting (perennials, groundcover) • herbs — 0.3m — planting (herb garden) • lawn — 0.05m — planting (grass area) • path — 0.05m — infrastructure (walkways) • building — 3.0m — infrastructure (structures) • terrace — 0.2m — infrastructure (paved patio) • parking — 0.05m — infrastructure (driveway, car space)
Inputs: zones (required).
capture_previewA
Capture a screenshot of the garden framed on the parcel (2 m margin), in the current view mode — switch to 2d with set_view_mode for a plan view. Returns an image you can view directly.
Inputs: maxSize.
clear_allA
Clear scene contents. Default scope='all' clears objects, zones, AND pins (matches the tool name's intent). Use scope='zones_pins' to preserve objects, or scope='objects' to preserve zones+pins. NOTE: behaviour change in this MCP version — previously this tool only cleared zones+pins regardless. Returns { success, scope, objectsCleared, zonesCleared, pinsCleared }.
Inputs: scope.
connection_statusB
Check if the browser is connected
Inputs: no named parameters.
delete_objectC
Delete a garden object by ID
Inputs: id (required).
delete_objectsB
Delete multiple garden objects by ID in a single call. Returns array of results.
Inputs: ids (required).
delete_pinC
Delete a pin by ID
Inputs: id (required).
delete_zoneC
Delete a zone by ID
Inputs: id (required).
export_stateA
Export the current state of all zones and pins as JSON
Inputs: no named parameters.
focus_onC
Focus the camera on a specific area in the garden
Inputs: x (required), y (required), width, height.
geocode_addressA
Find an address anywhere in the world (OpenStreetMap Nominatim). Returns {address, lat, lon, countryCode}; countryCode is ISO 3166-1 alpha-2 in lower case. The land-registry tools (get_parcel_by_*, import_parcel) work only for countryCode 'pl'; elsewhere set the garden's place with set_geo_anchor and the plot's boundary with set_boundary.
Inputs: address (required).
get_categoriesA
Get product categories for a layer. Architecture and ground are flat (1-level): any returned id works directly with search_products.categoryId. Plants use a 2-level tree: this returns only the 6 top-level groups (Drzewa, Krzewy, Pnącza, Byliny, Trawy Ozdobne, Pokroje); to filter search_products by plant category you must follow up with get_subcategories() and pass a leaf id.
Inputs: layer (required).
get_coordinate_systemB
Get the coordinate system documentation (units, axes, scale factor). Note: 50 editor units = 1 meter, origin top-left, X rightward, Y downward, rotation clockwise degrees.
Inputs: no named parameters.
get_design_guideA
The full design guide: step-by-step first-session workflow, how to read photos and floor plans onto facades, pin rules, the three zone passes with minimum sizes, the journal template, plant selection and verification. Call once at the start of a session.
Inputs: no named parameters.
get_full_stateA
Get the garden state. Default: full payload (summary + zones + pins + objects + layer visibility + view mode + geo-anchor + coordinate system) — use at session start. Pass summary_only=true on large scenes to skip the heavy arrays and return just the summary block + coordinateSystem (avoids exceeding the tool-result token budget).
Inputs: summary_only.
get_garden_infoA
Get garden metadata: ID, name, description, rotation, boundary, object counts
Inputs: no named parameters.
get_geo_anchorB
Get the current geo-anchor (if set)
Inputs: no named parameters.
get_layer_visibilityB
Get visibility state of all layers
Inputs: no named parameters.
get_objectsA
Get garden objects (plants, buildings, ground shapes). Default: full array. Optionally filter by layer. Pass count_only=true on large scenes to get aggregated counts ({total, byLayer, byType, byProductId}) instead of the array — avoids exceeding the tool-result token budget.
Inputs: layer, count_only.
get_objects_in_zoneA
Returns all garden objects whose center falls within the specified zone. Includes plants, buildings, and ground shapes. Useful for checking plant density, verifying placement, or listing zone contents.
Inputs: zoneId (required).
get_parcel_by_addressB
Get parcel information by address (geocodes then looks up parcel). Poland only: refused for a garden placed outside Poland.
Inputs: address (required).
get_parcel_by_coordinatesB
Get parcel information by WGS84 coordinates (lat/lon). Poland only: refused for a garden placed outside Poland.
Inputs: lat (required), lon (required).
get_parcel_by_idA
Get parcel information by parcel ID. Poland only: refused for a garden placed outside Poland.
Inputs: parcelId (required).
get_pinsB
Get all pins in the garden
Inputs: no named parameters.
get_plant_attributesA
Returns the full vocabulary of selectable plant filter values for the current viewer locale: enum lists (flowerColor, bloomPeriod, sunlight, soil, foliageType, foliageColor, maintenanceLevel, form) and observed numeric ranges (height, spread, hardiness). Call this BEFORE search_plants so you pick only valid values; values not in this vocabulary will yield empty results from search_plants. Lazy-loaded once per session and cached.
Inputs: no named parameters.
get_plant_infoA
Returns detailed botanical information for a plant product: characteristics (height, spread, form, foliage, flowers), requirements (soil, sunlight, hardiness), and maintenance schedule. Use this to make informed plant selection decisions.
Inputs: productId (required).
get_product_detailsB
Get full details for a specific product by ID
Inputs: productId (required).
get_reference_photosB
Get all uploaded reference photos for this session
Inputs: no named parameters.
get_site_analysisA
Measured site facts for placing pins and zones, computed from the parcel boundary and building zones (call after import_parcel + import_buildings). Returns (metres, garden coordinates): the parcel area and its edges by compass side; the user's house (largest building centred in the parcel) with each facade's compass side, length, from/to endpoints, midpoint, outward normal, whether it is a shared (party) wall, and gardenDepth — the free distance from the facade straight out to the boundary; neighbouring buildings with direction and whether attached; total garden area. Use it to put door pins ON the right facade and to check whether a terrace or bed fits on a side before drawing zones.
Inputs: no named parameters.
get_subcategoriesA
Get the leaf subcategories of a top-level plant category. Plants use a two-level tree (6 top-level → leaves); search_products's categoryId filter requires a leaf id. Architecture and ground are flat — calling this on their top-level ids returns []. Locale follows the editor session.
Inputs: parentId (required).
get_versionA
Returns version info for the MCP server and the connected browser editor. Use at session start to confirm you are talking to a build that supports the features you depend on (e.g. M25 plant-attribute search). Response: { mcpServer: { name, version }, editor: { version, buildTime, gitHash } | null }. The editor block is null when the browser is not connected.
Inputs: no named parameters.
get_view_modeA
Get the current view mode (2d or 3d)
Inputs: no named parameters.
get_zone_analysisA
Analyzes a zone's contents: object count, coverage %, planting density rating, and boundary violation warnings. Use after placing objects to validate density and spatial relationships.
Inputs: zoneId (required).
get_zonesA
Get all zones in the garden (editor geometry: centre + relative points; locked marks zones the design must not change). For absolute polygons and areas use get_site_analysis.
Inputs: no named parameters.
get_zone_typesA
Get all available zone types with their properties (colors, default heights, labels)
Inputs: no named parameters.
import_buildingsA
Scan the imported parcel + 10 m margin via ULDK and add discovered building footprints as building zones. Requires import_parcel first — uses the current parcel and geo-anchor. Blocks until the scan completes; typically 1–2 minutes for a residential parcel because ULDK is slow, so do not retry on perceived stalls. Re-runs are safe: buildings already imported are deduped by parcelBuildingId and reported under skipped. Returns { success, count, added, skipped, buildings: [{ zoneId, parcelBuildingId, functionLabel, centerX, centerY, width, height }] } (meters). The largest building whose center sits inside the parcel is usually the user's house; the rest are neighbors. Poland only: refused for a garden placed outside Poland.
Inputs: no named parameters.
import_parcelA
Import a parcel as the garden's site context: sets the scheme outline, geo-anchor, and (by default) auto-loads the KIEG WMS cadastral/satellite map background so capture_preview shows real site context (neighbors, road, vegetation) under the boundary. Default alignment is north_up so cardinal reasoning ("south wall", "west fence") works naturally; pass side_aligned if you'd rather draw on an axis-aligned canvas. WMS failure is non-fatal — boundary + geo-anchor still land and the response carries mapBackground: { loaded: false, reason } so you can decide whether to retry or continue without the background. Pass loadMapBackground: false to skip the WMS fetch entirely (faster; useful for headless evals). Poland only: refused for a garden placed outside Poland — draw the boundary with set_boundary instead.
Inputs: parcelId (required), alignment, loadMapBackground.
import_stateC
Import zones and pins from a JSON state object
Inputs: state (required).
map_to_gardenA
Where points on the laid survey map are in the garden, in metres — e.g. the plot's corners read off the map, for set_boundary. Points are given on any view of the laid map's image (see zoom_image).
Inputs: points (required).
redoB
Redo the last undone action
Inputs: no named parameters.
saveB
Save all changes to the server
Inputs: no named parameters.
search_plantsA
Filter the plant catalog by botanical attributes. Returns lean records ({productId, code, botanicalName, commonName}). Call get_plant_attributes first to discover valid filter values for the current locale. Multi-value filters use OR semantics (any value matches); different filters are AND-combined. Range filters use overlap semantics (a plant's range must intersect the requested range). Capped at limit (default 25, max 100); response includes total + truncated flag. Use get_plant_info for full per-plant details after picking a candidate. Falls back to a loud error if the index is unavailable on the CDN — agents should retry name-based queries via search_products in that case.
Inputs: soil, limit, query, height, +11 more.
search_productsB
Search the product catalog. Filter by layer (ground/architecture/plants), text query, or category.
Inputs: page, layer, query, perPage, +1 more.
set_boundaryA
Set the plot's boundary from a polygon — for a plot outside Poland, one the land registry gets wrong, or the designer's measurements ("18 by 25 m"). Absolute vertices in metres, in the garden coordinates zones use (the garden's place is at 0,0; x east, y south when north is up), e.g. traced from the OpenStreetMap background in capture_preview. Replaces any boundary; the change is unsaved until save. A placed plot becomes located and the map refits around it. Returns {area (m²), plot: 'located' | 'unlocated'}.
Inputs: polygon (required).
set_garden_descriptionA
Set the garden description (Markdown supported). Use as a design journal — write the brief, key decisions, rationale, current phase, and what's next. Persists across sessions.
Inputs: description (required).
set_garden_rotationC
Set the garden's north orientation in degrees
Inputs: degrees (required).
set_geo_anchorA
Set the garden's place: the real-world point (WGS84) at the editor origin. The plot becomes placed — north, sunlight and the OpenStreetMap background follow it — and the change is unsaved until save. Use it for a plot outside Poland (after geocode_address), then give the boundary with set_boundary; import_parcel sets both for a Polish parcel.
Inputs: lat (required), lon (required), editorX, editorY, +1 more.
set_layer_visibleC
Show or hide a rendering layer
Inputs: layer (required), visible (required).
set_map_backgroundA
Switch a map background under the garden on or off. 'osm' is the live OpenStreetMap map, about 100 m around the plot, turning with the garden; 'satellite' is the aerial photo of the same area (Poland only: the national orthophoto; elsewhere it answers that there is no photo) — fences, hedges, trees and paths show there, not on the street map. Both need the garden's place (set_geo_anchor or import_parcel), are loaded live and start off each time the garden opens. 'survey' is the survey map laid with set_survey_map (false hides it, true shows it again). They show in capture_preview and hide with the 'map' layer.
Inputs: kind (required), visible (required).
set_survey_mapA
Lay a map of the land drawn to scale (survey map, site plan, sketch with its lengths) that the designer attached in the chat under the garden, as a map background. Either matches: two or more points on the map matched to the same points in the garden (garden metres, e.g. boundary corners from get_garden_info) — scale, turn and position are fitted; from three matches you get how far each lands from its garden point. Or measure (a plot with no place or boundary): two points on the map and the real distance between them — the map lies to scale, as drawn, from at at. Pick points far apart, zoom_image to place them exactly, then check with capture_preview. Laying again replaces the map. The next save keeps it with the garden, in the place of a kept cadastral map (which can still be downloaded and shown).
Inputs: matches, measure.
set_unitsA
Set the unit system for coordinate inputs/outputs. Default is "m" (meters). When set to "m", all spatial values (x, y, width, height, points) are in meters. When "editor", values use raw editor units (50 units = 1 meter).
Inputs: unit (required).
set_view_modeA
Switch between 2D (top-down) and 3D (perspective) view
Inputs: mode (required).
undoC
Undo the last action
Inputs: no named parameters.
update_objectA
Update a garden object's position, size, rotation, or swap its product. To swap product: pass productId or productQuery. Plants/buildings get new dimensions from catalog; ground shapes keep their shape and only swap texture.
Inputs: id (required), x, y, label, +6 more.
update_objectsB
Update multiple garden objects in a single call. Returns array of results. Each item can swap its product with productId or productQuery, as in update_object.
Inputs: objects (required).
update_zoneA
Update an existing zone. Reshape it with polygon or path (absolute, metres) or with x/y/width/height/points; lock or unlock it with locked. Returns checks for the updated zone (area, narrowest width, overlaps, parcel overflow).
Inputs: id (required), x, y, path, +10 more.
upload_reference_photoB
Upload a reference photo (house exterior, current garden). Stored in-session. The AI agent can analyze photos via its own vision capabilities.
Inputs: label (required), dataUri (required).
zoom_imageA
Look closer at an image the designer attached in the chat (e.g. a survey map) to place points precisely. Attached images arrive labelled "Image 1", "Image 2"…; each is a view ("1") in the pixels you see. Returns a close-up of the full-size original around a point of a view, as a new view ("1.1", "1.2"…) with its own pixels. Points for set_survey_map and map_to_garden are given on any view. Only in the editor's own chat, where images are attached.
Inputs: x (required), y (required), view (required), size.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 63 tools
Most tools have distinct domain roles, but there are many closely related pairs: add_pin/add_pins, add_zone/add_zones, add_object/add_objects, update_object/update_objects, get_full_state/export_state, and get_garden_info/get_site_analysis. Descriptions usually clarify intended use, but the agent must frequently choose between singular/bulk variants and overlapping state/query tools.
The set overwhelmingly uses snake_case with predictable verb_noun forms such as get_*, set_*, add_*, update_*, and delete_*. A few tools deviate, including connection_status and bare save/undo/redo, but the overall convention remains readable and stable.
63 tools is excessive for an MCP surface, even for a broad garden-design editor. The count is inflated by singleton/bulk CRUD variants plus many specialized state, geospatial, catalog, view, and plant-query tools, making discovery and selection burdensome.
Coverage is strong across zones, objects, pins, garden metadata, geospatial parcel workflows, products/plants, view/layers, persistence, and undo/redo. Minor gaps exist, such as no dedicated update_pin operation, but most core workflows are supported.
Maintenance
Related MCP Connectors
Identify plants, mushrooms and insects, and keep your garden’s records and jobs, from your AI.
Design a house, its rooms and its garden in AI Plan Creator by asking in a chat.
AI interior, exterior and landscape design, photoreal rendering, image editing, video and 3D.
Design homes with your AI: floor plans, furniture, joinery, lighting and photos, live.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI assistants to interact with Autodesk Civil 3D, allowing them to retrieve project data, create/modify/delete drawing elements, and execute code to automate Civil 3D operations.350MIT
- AlicenseAqualityCmaintenanceEnables AI assistants to interact with Autodesk Civil 3D through natural language, supporting tools for surfaces, alignments, profiles, corridors, pipe networks, COGO points, and AutoCAD geometry.94MIT
- AlicenseAqualityFmaintenanceEnables AI assistants to assess any parcel for micro-farm viability (climate, water, farmland context, access, flood risk) and dwelling feasibility, and to find real land for sale from free, keyless public data sources.51MIT
- FlicenseNot gradedqualityAmaintenanceEnables AI assistants to control supported CAD applications through natural-language or direct tool calls for drawing, layer, block, entity, file, and data-export operations.-