Evaluation/Sketchup-Booth-Designer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial checkin

Browse Source
This commit is contained in:
root
2026-09-29 09:44:16 +00:00
commit 01569b00b5
7 changed files with 1701 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+76
View File
@@ -0,0 +1,76 @@
# Expolinc Booth Designer
**AI-driven trade fair booth design for Expolinc modular exhibition systems, powered by FreeCAD + MCP.**
Design complete trade fair booths using Expolinc Classic Frame and Light Frame components — via natural language commands through an AI assistant (Claude, etc.). Generate 3D models, technical drawings, and bill of materials from simple descriptions like *"a 4x3m island booth with backlit walls and storage room."*
## Features
- **Parametric Expolinc component library** — Classic Frame profiles, Light Frame backlit modules, connectors, storage rooms, doors, and accessories as parametric FreeCAD objects
- **MCP server integration** — Extends the [sergiudanstan/freecad-mcp](https://github.com/sergiudanstan/freecad-mcp) server with 12 Expolinc-specific tools
- **Layout engine** — Supports inline, corner, peninsula, island, and custom booth configurations
- **Bill of materials** — Component count, dimensions, weights, part numbers, recommended transport cases
- **Technical drawings** — Dimensioned multi-view drawings via FreeCAD TechDraw
- **CAD export** — STEP, STL, OBJ, DXF for manufacturing handoff
## Systems Supported
| System | Description | Sizes |
|---|---|---|
| **Classic Frame** | Modular aluminum frame with SEG fabric graphics, tool-less magnetic assembly | Widths: 500–4950mm, Heights: 2500/3000mm |
| **Light Frame** | Backlit LED frame system, integrates with Classic Frame | Same sizes + LED temperature/brightness config |
| **Connectors** | 90° corner, 180° inline, T-connector | — |
| **Accessories** | Storage rooms, doors, shelves, bridge connectors, support feet | — |
## Quick Start
```bash
# 1. Install FreeCAD 1.0+ from freecad.org
# 2. Clone the repository
git clone https://github.com/your-org/expolinc-booth-designer
cd expolinc-booth-designer
# 3. Install component library
cp -r ExpolincLib /path/to/FreeCAD/Mod/
# 4. Install MCP server
npm install
npm run build
# 5. Add to your AI assistant's MCP configuration
# See docs/INSTALL.md for details
```
## Project Structure
```
expolinc-booth-designer/
├── ExpolincLib/ # FreeCAD Python component library
│ ├── __init__.py
│ ├── classic_frame.py # Classic Frame parametric components
│ ├── light_frame.py # Light Frame parametric components
│ ├── connectors.py # Corner and inline connectors
│ ├── accessories.py # Storage rooms, doors, shelves
│ ├── layouts.py # Booth layout generators
│ ├── bom.py # Bill of materials generator
│ └── specs.py # Expolinc official specifications
├── mcp-server/ # FreeCAD MCP server extension
│ ├── src/
│ │ ├── server.ts # MCP server entry point
│ │ ├── expolinc_tools.ts # Expolinc-specific MCP tools
│ │ ├── layout_engine.ts # Booth layout logic
│ │ └── bom_generator.ts # BOM generation logic
│ └── package.json
├── docs/
│ ├── ARCHITECTURE.md # System architecture
│ ├── INSTALL.md # Installation guide
│ ├── COMPONENT_LIBRARY.md # Component library reference
│ ├── MCP_TOOLS.md # MCP tools reference
│ ├── BOOTH_LAYOUTS.md # Booth layout patterns
│ └── BILL_OF_MATERIALS.md # BOM output guide
└── README.md
```
## License
MIT
docs/ARCHITECTURE.md
+174
View File
@@ -0,0 +1,174 @@
# Architecture
## System Overview
The Expolinc Booth Designer connects three layers: the **AI assistant**, the **MCP server bridge**, and **FreeCAD** acting as the geometry engine.
```
┌──────────────────────────────────────────────────┐
│ AI Assistant │
│ (Claude Desktop / Claude Code) │
│ "build a 4x3m island booth with 2 backlit walls" │
└──────────────────────┬───────────────────────────┘
│ MCP protocol (stdio JSON-RPC)
▼
┌──────────────────────────────────────────────────┐
│ MCP Server (Node.js/TS) │
│ │
│ ┌─────────────────┐ ┌──────────────────────┐ │
│ │ Built-in tools │ │ Expolinc tools │ │
│ │ (165 tools from │ │ 12 custom tools: │ │
│ │ freecad-mcp) │ │ build_booth, │ │
│ │ │ │ create_wall, │ │
│ │ - BIM primitives │ │ export_bom, │ │
│ │ - Part operations│ │ arrange_layout, ... │ │
│ │ - TechDraw │ └──────────────────────┘ │
│ │ - Import/Export │ │
│ └─────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ Layout Engine │ │
│ │ Interprets booth spec → wall positions → │ │
│ │ component list → placement coordinates │ │
│ └──────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ BOM Generator │ │
│ │ Component count, weights, transport cases, │ │
│ │ SEG graphic area, part numbers │ │
│ └──────────────────────────────────────────────┘ │
└──────────────────────┬───────────────────────────┘
│ TCP JSON-RPC :12345
▼
┌──────────────────────────────────────────────────┐
│ FreeCAD (GUI or headless) │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ ExpolincLib (Python) │ │
│ │ │ │
│ │ classic_frame.py ── App::FeaturePython │ │
│ │ light_frame.py ── Parametric objects │ │
│ │ connectors.py ── Placement helpers │ │
│ │ accessories.py ── Storage, doors, etc. │ │
│ │ layouts.py ── Assembly builder │ │
│ │ bom.py ── Spreadsheet output │ │
│ └──────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ FreeCAD Workbenches Used │ │
│ │ - Part (primitives, booleans) │ │
│ │ - PartDesign (sketches, pads, pockets) │ │
│ │ - BIM (walls, slabs for booth structure) │ │
│ │ - TechDraw (dimensioned drawings) │ │
│ │ - Spreadsheet (BOM data) │ │
│ └──────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────┘
```
## Data Flow
### Booth Creation Flow
```
User: "Build a 6x4m island booth with 2.5m Classic Frame walls,
backlit on walls 0 and 2, with a storage room"
1. MCP Server receives `expolinc_build_booth` tool call
2. Layout Engine parses parameters:
- Layout: island (4 walls, open all sides)
- Wall 0: 6000×2500mm Classic Frame + Light Frame backlit
- Wall 1: 4000×2500mm Classic Frame
- Wall 2: 6000×2500mm Classic Frame + Light Frame backlit
- Wall 3: 4000×2500mm Classic Frame
- Storage: 1950×1000×2500mm
3. Layout Engine computes wall positions:
- Wall 0: position (0,0,0), rotation 0°
- Wall 1: position (6000,0,0), rotation 90°
- Wall 2: position (6000,4000,0), rotation 180°
- Wall 3: position (0,4000,0), rotation -90°
- 4× 90° corner connectors at each junction
- Storage room attached to Wall 3
4. BOM Generator calculates:
- 2× Classic Frame 4950mm + 2× extension profiles
- 2× Light Frame 4950mm
- 4× 90° corner connectors
- 8× support feet
- 1× Storage room kit
- SEG graphic area: ~50 m²
- Total weight: ~120 kg
- Recommended transport: 2× Standard Case XL
5. FreeCAD creates:
- 4 FCStd documents with parametric components
- Assembly with placements
- Spreadsheet with BOM data
6. Response returned with:
- Document reference
- BOM as structured data
- Preview screenshot (if GUI mode)
```
### MCP Tool Dispatch
```
Client → MCP Server → freecad-mcp bridge → FreeCAD TCP server → ExpolincLib
```
Each Expolinc tool call:
1. Validates parameters at the MCP server level
2. Translates to FreeCAD Python script
3. Sends to FreeCAD via JSON-RPC
4. FreeCAD executes on main thread via task queue
5. Returns result (object IDs, geometry metadata, or file paths)
## Module Responsibilities
### ExpolincLib (Python, runs inside FreeCAD)
| Module | Responsibility |
|---|---|
| `classic_frame.py` | Create Classic Frame walls: aluminum profile frame, SEG graphic panel, support feet. Parameters: width, height, double_sided |
| `light_frame.py` | Create Light Frame backlit walls: LED frame, diffuser, LED strip, power supply housing. Parameters: width, height, led_temp, brightness |
| `connectors.py` | Create 90° corner connectors, 180° inline connectors, T-connectors. Handles placement alignment between adjacent walls |
| `accessories.py` | Create storage rooms (enclosed box frame + door), hinged/pocket doors, shelves, bridge connectors between parallel walls |
| `layouts.py` | Orchestrate wall placement for each layout type. Computes positions from booth dimensions. Handles corner alignment |
| `bom.py` | Traverse the document tree, enumerate Expolinc components, collect parameters, output CSV/JSON/spreadsheet |
| `specs.py` | Official Expolinc dimensional specs, weight tables, available sizes, material properties |
### MCP Server Extension (TypeScript, runs as MCP stdio server)
| Module | Responsibility |
|---|---|
| `server.ts` | Extends freecad-mcp with Expolinc tool registration, parameter validation, error handling |
| `expolinc_tools.ts` | Tool definitions: parameter schemas, descriptions, FreeCAD script generation |
| `layout_engine.ts` | Booth geometry math: wall positioning, corner fitting, grid alignment (990mm grid) |
| `bom_generator.ts` | Parse BOM response from FreeCAD, format as CSV/JSON, calculate totals |
## Data Sources
All Expolinc specification data (dimensions, weights, materials, LED specs) is sourced from:
1. **Expolinc official website** — product pages for Classic Frame and Light Frame list exact weights per size
2. **Expolinc Catalog 2020/2021** (PDF) — full product catalog with dimensions
3. **Expolinc Panel Guide 2024** (PDF) — SEG graphic panel specifications
4. **SketchUp 3D Warehouse** (`3dwarehouse.sketchup.com/by/expolinc`) — official 3D models for dimensional reference
5. **Expolinc Google Drive** — per-product folders with CAD files, setup instructions, templates
All weight data has been verified against the official website. The 3D models are SketchUp format (.skp) and serve as reference for profile cross-sections and connector details — they cannot be directly converted to parametric FreeCAD FeaturePython objects.
## FreeCAD Configuration
### GUI Mode (recommended for design)
FreeCAD runs with UI visible. The MCP server connects via the TCP addon. Users see changes live in the 3D viewport.
### Headless Mode (for automation / CI)
FreeCAD is imported as a Python module (`freecadcmd`). No GUI. Suitable for batch BOM generation or scripted production of standard booth layouts.
## Port Layout
| Port | Service | Protocol |
|---|---|---|
| `12345` | freecad-mcp addon (TCP) | JSON-RPC |
| `12346` | ExpolincLib internal | JSON-RPC (optional) |
| `stdin/stdout` | MCP server ↔ AI assistant | JSON-RPC (MCP) |
docs/BILL_OF_MATERIALS.md
+256
View File
@@ -0,0 +1,256 @@
# Bill of Materials Guide
## Overview
The Expolinc Booth Designer generates a structured bill of materials (BOM) for every booth design. The BOM includes all Expolinc system components, connectors, accessories, weights, and transport recommendations.
## BOM Structure
### Component Types
| Type | Examples |
|---|---|
| `classic_frame_wall` | Classic Frame walls of various sizes |
| `light_frame_wall` | Light Frame backlit walls |
| `connector_90` | 90° corner connectors |
| `connector_180` | Inline connectors |
| `connector_t` | T-connectors |
| `support_feet` | Double-sided support feet (pair) |
| `storage_room` | Storage room enclosure |
| `door` | Hinged or sliding door |
| `shelf` | Shelf unit |
| `seg_graphic` | SEG fabric graphic panel |
| `led_driver` | LED driver/power supply |
| `transport_case` | Shipping/storage case |
### BOM Output Formats
| Format | Description | Use Case |
|---|---|---|
| **JSON** | Structured data, machine-readable | Integration with ordering systems |
| **CSV** | Table format | Spreadsheet import, purchasing |
| **FreeCAD Spreadsheet** | Live spreadsheet in document | In-document reference |
| **Summary** | Human-readable text | Quick overview for AI response |
## JSON Output Example
```json
{
"project": "Booth_Island_6x4",
"date": "2026-05-30",
"layout": "island",
"dimensions": {
"width_mm": 6000,
"depth_mm": 4000,
"height_mm": 2500
},
"components": [
{
"part_number": "CF-4950-2500",
"name": "Classic Frame Wall 4950×2500mm",
"system": "classic_frame",
"category": "wall",
"quantity": 2,
"width_mm": 4950,
"height_mm": 2500,
"weight_kg": 25.0,
"total_weight_kg": 50.0,
"seg_area_m2": 12.375,
"finish": "silver",
"notes": "Main walls front and back"
},
{
"part_number": "CF-950-2500",
"name": "Classic Frame Wall 950×2500mm",
"system": "classic_frame",
"category": "wall",
"quantity": 2,
"width_mm": 950,
"height_mm": 2500,
"weight_kg": 10.5,
"total_weight_kg": 21.0,
"seg_area_m2": 2.375,
"finish": "silver",
"notes": "Side wall extensions"
},
{
"part_number": "LF-4950-2500",
"name": "Light Frame Wall 4950×2500mm",
"system": "light_frame",
"category": "wall",
"quantity": 2,
"width_mm": 4950,
"height_mm": 2500,
"weight_kg": 27.5,
"total_weight_kg": 55.0,
"led_temperature_K": 4000,
"led_brightness_lm": 1500,
"notes": "Backlit feature walls"
},
{
"part_number": "CN-90-STD",
"name": "90° Corner Connector",
"system": "connector",
"category": "connector",
"quantity": 4,
"weight_kg": 1.5,
"total_weight_kg": 6.0,
"finish": "silver"
},
{
"part_number": "SF-DBL",
"name": "Support Feet (double-sided, pair)",
"system": "accessory",
"category": "feet",
"quantity": 8,
"weight_kg": 0.8,
"total_weight_kg": 6.4
},
{
"part_number": "SR-1950-1000-2500",
"name": "Storage Room 1950×1000×2500mm",
"system": "accessory",
"category": "storage",
"quantity": 1,
"width_mm": 1950,
"depth_mm": 1000,
"height_mm": 2500,
"weight_kg": 35.0,
"total_weight_kg": 35.0,
"has_door": true,
"door_type": "hinged",
"has_shelving": false
}
],
"totals": {
"component_count": 19,
"total_weight_kg": 173.4,
"seg_area_m2": 29.5,
"connector_count": {
"90_degree": 4,
"180_inline": 0,
"T": 0
},
"light_frame_walls": 2,
"storage_rooms": 1,
"doors": 1,
"transport_cases": [
{
"type": "Standard Case XL",
"dimensions_mm": "1200×800×500",
"quantity": 3,
"notes": "For walls and connectors"
},
{
"type": "Travel Set (soft bag)",
"quantity": 1,
"notes": "For accessories and small parts"
}
],
"estimated_setup_time_minutes": 60,
"estimated_crew": 2
}
}
```
## CSV Output Example
```csv
part_number,name,system,category,qty,width_mm,height_mm,weight_kg,total_kg,notes
CF-4950-2500,Classic Frame Wall 4950x2500mm,classic_frame,wall,2,4950,2500,25.0,50.0,Main walls
CF-950-2500,Classic Frame Wall 950x2500mm,classic_frame,wall,2,950,2500,10.5,21.0,Side extensions
LF-4950-2500,Light Frame Wall 4950x2500mm,light_frame,wall,2,4950,2500,27.5,55.0,Backlit
CN-90-STD,90° Corner Connector,connector,connector,4,,,1.5,6.0,
SF-DBL,Support Feet (pair),accessory,feet,8,,,0.8,6.4,
SR-1950-1000-2500,Storage Room,accessory,storage,1,1950,2500,35.0,35.0,
```
## FreeCAD Spreadsheet BOM
When `expolinc_export_bom` is called with `format="spreadsheet"`, a FreeCAD Spreadsheet object is created in the active document:
| Cell | Content |
|---|---|
| `A1` | **Booth BOM** (title) |
| `A3` | **Component** |
| `B3` | **System** |
| `C3` | **Qty** |
| `D3` | **Width (mm)** |
| `E3` | **Height (mm)** |
| `F3` | **Unit Weight (kg)** |
| `G3` | **Total Weight (kg)** |
| `H3` | **Area (m²)** |
| `A4..H{n}` | Component data |
| Last row | **Totals** with SUM formulas |
## Weight Reference Tables
### Classic Frame Weights
| Width × Height | Weight (kg) |
|---|---|
| 500 × 2500 mm | 8.3 |
| 950 × 2500 mm | 10.5 |
| 1950 × 2500 mm | 14.5 |
| 2950 × 2500 mm | 16.5 |
| 3950 × 2500 mm | 20.4 |
| 4950 × 2500 mm | 25.0 |
| 500 × 3000 mm | 9.5 |
| 950 × 3000 mm | 12.0 |
| 1950 × 3000 mm | 18.3 |
| 2950 × 3000 mm | 23.3 |
| 3950 × 3000 mm | 26.3 |
| 4950 × 3000 mm | 28.5 |
### Light Frame Additional Weight
Light Frame walls add the following over the base Classic Frame weight: +2.5 kg (LED frame + diffuser + LED strip + driver).
### Connector Weights
| Connector | Weight (kg) |
|---|---|
| 90° corner connector | 1.5 |
| 180° inline connector | 1.2 |
| T-connector | 1.8 |
| Support feet (pair) | 0.8 |
### Accessory Weights
| Accessory | Weight (kg) |
|---|---|
| Storage room (1950×1000×2500mm) | 35.0 |
| Door (hinged, 900×2200mm) | 8.0 |
| Door (sliding, 900×2200mm) | 10.0 |
| Shelf unit (950×400mm, 3 levels) | 6.0 |
## Transport Case Selection
The BOM generator automatically recommends transport cases based on component sizes and quantities.
| Case Type | Capacity | Suitable For |
|---|---|---|
| **Basic Box** (cardboard) | Single wall up to 1950mm | One-time use, small walls |
| **Travel Set** (soft bag with wheels) | 1–2 walls + accessories | Frequent travel, medium booths |
| **Standard Case XL** (hard case) | Multiple walls + connectors | Large booths, frequent use |
**Recommendation logic:**
- Total weight < 50 kg → 1× Travel Set
- Total weight 50–100 kg → 1× Standard Case XL
- Total weight > 100 kg → Multiple Standard Case XL cases (calculated by volume)
## Using the BOM for Ordering
The generated BOM can be sent directly to Expolinc or an authorized distributor for component ordering. Each component includes:
- Expolinc part number (based on type and dimensions)
- Quantity required
- Finish specification
- Notes on configuration
To generate an order-ready BOM:
```
User: "Export the bill of materials as CSV for ordering"
Assistant: → expolinc_export_bom(format="csv", filepath="booth_bom_2026-05-30.csv")
```
docs/BOOTH_LAYOUTS.md
+269
View File
@@ -0,0 +1,269 @@
# Booth Layout Guide
## Overview
The Expolinc Booth Designer supports the standard trade fair booth layout types. Each layout determines how walls are arranged, which sides are open, and what components are needed.
## Layout Types
### Inline (Row Booth)
A booth with one back wall and open front side. The most economical and common layout for small spaces.
```
Front (open)
┌─────────────────────┐
│ │
│ │ ← Side wall (optional)
│ │
└─────────────────────┘
Back wall
```
| Property | Value |
|---|---|
| **Open sides** | 1 (front) |
| **Typical dimensions** | 3m–6m wide × 2m–3m deep |
| **Walls** | 1 back wall, 0–2 partial side walls |
| **Connectors** | 0–2 corner connectors |
| **Best for** | Small budgets, product display, 1–2 staff |
**Example command:**
```
Build a 4m wide inline booth, 2.5m high, with 2m depth,
and double-sided side walls
```
---
### Corner (2-Side Open)
A booth with two adjacent walls forming a 90° corner. Two aisles of foot traffic.
```
Front (open)
┌─────────────────────┐
│ │
│ │
│ ┌────┤
│ │ │
Side (open) └────┘
Wall B
```
| Property | Value |
|---|---|
| **Open sides** | 2 (front and one side) |
| **Typical dimensions** | 3m–6m per wall |
| **Walls** | 2 walls at 90° |
| **Connectors** | 1 × 90° corner connector |
| **Best for** | Medium budgets, higher visibility, product demonstration |
**Example command:**
```
Build a corner booth with walls 4m and 3m, 2.5m high,
with a storage room behind the 4m wall
```
---
### Peninsula (3-Side Open / U-Shape)
A U-shaped booth at the end of a row, open on three sides.
```
Front (open)
┌─────────────────────┐
│ │
│ │
│ │
└───────┬─────┬───────┘
│ │
Wall A│ │Wall B
│ │
```
| Property | Value |
|---|---|
| **Open sides** | 3 (front, left, right) |
| **Typical dimensions** | 4m–8m wide × 3m–6m deep |
| **Walls** | 3 walls (back + 2 sides) |
| **Connectors** | 2 × 90° corner connectors |
| **Best for** | Large product displays, high traffic, 3+ staff |
**Example command:**
```
Build a 6m wide by 4m deep peninsula booth, 2.5m high,
with backlit back wall
```
---
### Island (4-Side Open)
A freestanding booth open on all sides. Maximum visibility and foot traffic.
```
┌─────────────────────┐
│ │
│ │
│ │
│ │
└─────────────────────┘
Open on all 4 sides
```
| Property | Value |
|---|---|
| **Open sides** | 4 (all sides) |
| **Typical dimensions** | 4m–12m per side |
| **Walls** | 4 walls (full perimeter) |
| **Connectors** | 4 × 90° corner connectors |
| **Best for** | Flagship presence, large brands, product launches, 4+ staff |
**Example command:**
```
Build a 6×4m island booth with 2.5m walls, backlit on
walls 0 and 2, with a storage room on wall 1
```
---
### Face-to-Face
Two parallel walls facing opposite aisles, open on the sides.
```
Side (open)
┌─────────────────────┐
│ Wall A │
└─────────────────────┘
┌─────────────────────┐
│ Wall B │
└─────────────────────┘
Side (open)
```
| Property | Value |
|---|---|
| **Open sides** | 2 (left, right) |
| **Typical dimensions** | 3m–6m per wall, 2m–4m apart |
| **Walls** | 2 parallel walls |
| **Connectors** | None (freestanding) |
| **Best for** | Through-aisle positions, product display both sides |
---
## Grid System
Expolinc components use a **990mm grid** (standard exhibition grid). Wall widths should ideally be multiples of this grid for optimal component fit.
| Grid Units | Width (mm) | Standard Sizes |
|---|---|---|
| 0.5× grid | 495 | — |
| 1× grid | 990 | 950mm (nominal) |
| 2× grid | 1980 | 1950mm |
| 3× grid | 2970 | 2950mm |
| 4× grid | 3960 | 3950mm |
| 5× grid | 4950 | 4950mm |
| Custom | Any | Built from multiple sections |
The layout engine automatically selects the best combination of standard sizes to match requested booth dimensions.
## Component Placement Rules
### Wall Orientation
```
Z (up)
│
│ ┌──────────────┐
│ │ │
│ │ Wall │──→ Y (depth)
│ │ │
│ └──────────────┘
└────────────────────→ X (width)
```
- Walls are created in the XY plane (vertical)
- Rotation is around the Z axis
- 0° = facing +Y direction
- 90° = facing +X direction
- 180° = facing −Y direction
- −90° = facing −X direction
### Corner Joining
When two walls meet at a corner:
- The corner connector is placed at the intersection point
- Each wall is inset by half the profile thickness from the corner
- The connector bridges the gap and provides structural continuity
### Storage Room Placement
Storage rooms are placed behind a wall (on the exterior side):
- Width matches the wall section it attaches to
- Depth extends outward from the booth
- A door is placed on the interior side
## Size Recommendations
| Booth Size | Layout | Components Estimate |
|---|---|---|
| 9 m² (3×3m) | Inline | 1× Classic Frame wall, 2× side walls |
| 12 m² (4×3m) | Corner | 2× walls, 1× corner connector |
| 18 m² (6×3m) | Peninsula | 3× walls, 2× corner connectors |
| 24 m² (6×4m) | Island | 4× walls, 4× corner connectors |
| 36 m² (6×6m) | Island | 4× walls (larger), 4× corner connectors |
| 48 m² (8×6m) | Island | 4× walls + storage rooms |
| 88 m² | Custom | Multiple wall sections, storage, backlit |
## Combining Classic Frame and Light Frame
Classic Frame and Light Frame modules are fully compatible and can be mixed within a single booth:
- **Classic Frame** — Standard wall sections with SEG fabric graphics
- **Light Frame** — Backlit sections for highlights, logos, product emphasis
- **Integration** — Same frame dimensions, connectors, and grid system
Design guideline: Use Light Frame for 20–30% of wall area (brand focal points) and Classic Frame for the remaining area.
## Example Booth Configurations
### Example 1: 12m² Corner Booth
```
Layout: Corner
Width A: 4000mm → 1× Classic Frame 3950mm + 1× filler 50mm
Width B: 3000mm → 1× Classic Frame 2950mm + 1× filler 50mm
Height: 2500mm
System: Classic Frame
Backlit: Wall A (brand logo area)
Storage: 1950×1000mm behind Wall B
```
### Example 2: 24m² Island Booth with Backlit
```
Layout: Island
Width: 6000mm → 1× Classic Frame 4950mm + 1× 950mm
Depth: 4000mm → 1× Classic Frame 3950mm
Height: 2500mm
System: Classic Frame + Light Frame
Backlit: Walls 0, 2
Storage: 1950×1000mm on Wall 1
```
### Example 3: 36m² Large Island
```
Layout: Island
Width: 6000mm → 2× Classic Frame 2950mm per side
Depth: 6000mm → 2× Classic Frame 2950mm per side
Height: 2500mm + 3000mm (feature wall)
System: Classic Frame
Feature: Wall 0 at 3000mm height, double-sided
Storage: 2950×1500mm room on Wall 2
Doors: Sliding door on storage room
```
docs/COMPONENT_LIBRARY.md
+353
View File
@@ -0,0 +1,353 @@
# Expolinc Component Library Reference
## Overview
`ExpolincLib` is a Python module for FreeCAD that provides parametric models of all Expolinc exhibition system components. Each component is a `App::FeaturePython` parametric object — changes to parameters automatically regenerate the geometry.
## Module Structure
```
ExpolincLib/
├── __init__.py # Package init, version, imports
├── specs.py # Official Expolinc specifications and constants
├── classic_frame.py # Classic Frame system components
├── light_frame.py # Light Frame backlit system components
├── connectors.py # Corner and inline connectors
├── accessories.py # Storage rooms, doors, shelves
├── layouts.py # Booth layout assembly functions
└── bom.py # Bill of materials generation
```
## Common Parameters
All components share these standard parameters:
| Parameter | Type | Default | Description |
|---|---|---|---|
| `width` | float (mm) | — | Component width |
| `height` | float (mm) | — | Component height |
| `system` | string | `"classic_frame"` | System type: `"classic_frame"` or `"light_frame"` |
| `placement` | Placement | `App.Placement()` | Position and rotation in the document |
---
## Classic Frame
### `ClassicFrameWall`
Creates a complete Classic Frame wall assembly: aluminum frame + SEG fabric graphic + support feet.
**Parameters:**
| Parameter | Type | Range | Default | Description |
|---|---|---|---|---|
| `width` | int (mm) | 500, 950, 1950, 2950, 3950, 4950 | 1950 | Wall width |
| `height` | int (mm) | 2500, 3000 | 2500 | Wall height |
| `is_double_sided` | bool | — | `false` | Double-sided (graphic on both sides) |
| `finish` | string | `"silver"`, `"white"`, `"black"` | `"silver"` | Profile anodized finish |
| `include_feet` | bool | — | `true` | Include support feet |
| `include_graphic` | bool | — | `true` | Include SEG fabric graphic |
| `graphic_color` | tuple (R,G,B) | 0–255 per channel | `(255,255,255)` | Placeholder graphic color |
**Available sizes:**
| Width (mm) | Height 2500mm | Height 3000mm |
|---|---|---|
| 500 | ✓ | ✓ |
| 950 | ✓ | ✓ |
| 1950 | ✓ | ✓ |
| 2950 | ✓ | ✓ |
| 3950 | ✓ | ✓ |
| 4950 | ✓ | ✓ |
**Example:**
```python
from ExpolincLib.classic_frame import ClassicFrameWall
wall = ClassicFrameWall(
width=2950,
height=2500,
is_double_sided=True,
finish="silver"
)
doc.addObject("Part::FeaturePython", "Wall_2950x2500", wall)
```
### `ClassicFrameProfile`
A single aluminum extrusion profile (one section of a frame). Used internally by `ClassicFrameWall`.
**Parameters:** `length`, `profile_type` (`"horizontal"`, `"vertical"`), `finish`
---
## Light Frame
### `LightFrameWall`
Creates a backlit Light Frame wall: LED frame, diffuser panel, LED strip, power supply.
**Parameters:**
| Parameter | Type | Range | Default | Description |
|---|---|---|---|---|
| `width` | int (mm) | 500, 950, 1950, 2950, 3950, 4950 | 1950 | Wall width |
| `height` | int (mm) | 2500, 3000 | 2500 | Wall height |
| `led_temperature` | int (K) | 2700–6500 | 4000 | LED color temperature in Kelvin |
| `brightness` | int (lm) | 500–3000 | 1000 | LED brightness in lumens |
| `diffuser_type` | string | `"opal"`, `"microprism"` | `"opal"` | Diffuser type |
| `include_driver` | bool | — | `true` | Include LED driver/power supply |
**Example:**
```python
from ExpolincLib.light_frame import LightFrameWall
backlit = LightFrameWall(
width=2950,
height=2500,
led_temperature=4000,
brightness=1500
)
```
---
## Connectors
### `CornerConnector90`
Creates a 90° corner connector joining two walls at right angles.
**Parameters:** `wall_thickness`, `finish`
### `InlineConnector180`
Creates an inline connector joining two wall sections end-to-end.
**Parameters:** `wall_thickness`, `finish`
### `TConnector`
Creates a T-connector for three-way junctions.
**Parameters:** `wall_thickness`, `finish`
**Example:**
```python
from ExpolincLib.connectors import CornerConnector90
corner = CornerConnector90(wall_thickness=40, finish="silver")
```
The `layouts.py` module automatically places appropriate connectors when building booth layouts.
---
## Accessories
### `StorageRoom`
Creates an enclosed storage room attached to a wall.
| Parameter | Type | Default | Description |
|---|---|---|---|
| `width` | int (mm) | 1950 | Room width |
| `depth` | int (mm) | 1000 | Room depth |
| `height` | int (mm) | 2500 | Room height |
| `has_door` | bool | `true` | Include access door |
| `door_type` | string | `"hinged"` | `"hinged"` or `"sliding"` |
| `has_shelving` | bool | `false` | Include interior shelves |
### `BoothDoor`
A door panel for integration into a wall.
| Parameter | Type | Default | Description |
|---|---|---|---|
| `width` | int (mm) | 900 | Door width |
| `height` | int (mm) | 2200 | Door height |
| `type` | string | `"hinged"` | `"hinged"`, `"sliding"`, `"pocket"` |
| `handle_style` | string | `"pull"` | `"pull"`, `"push"`, `"recessed"` |
### `Shelf`
A shelf unit for accessory display.
| Parameter | Type | Default | Description |
|---|---|---|---|
| `width` | int (mm) | 950 | Shelf width |
| `depth` | int (mm) | 400 | Shelf depth |
| `count` | int | 3 | Number of shelf levels |
---
## Data Sources
Spec data for `specs.py` is sourced from Expolinc's official materials. All values have been verified against the following sources:
| Source | URL | Data |
|---|---|---|
| **Expolinc website** — Classic Frame | `expolinc.com/exhibition-stands/classic-frame` | Widths, heights, weights per size, finish options |
| **Expolinc website** — Light Frame | `expolinc.com/exhibition-stands/light-frame` | Widths, heights, weights, LED options |
| **Expolinc Catalog 2020/2021** (PDF) | `sgpweb.com/wp-content/uploads/2021/08/Expolinc-Catalog-2020.2021-1.pdf` | Full product catalog with dimensions and specs |
| **Expolinc Panel Guide 2024** (PDF) | `sesoma.fi/media/wysiwyg/Datasheets/Expolinc_Panel_Guide_Eng_2024.pdf` | Panel thickness, SEG graphic specs |
| **Expolinc Google Drive** | `drive.google.com/drive/folders/1dc39tZQXvJbQbA7aKwICUiL6y6gq9miC` | CAD files, setup instructions, templates |
### 3D Models (Reference Only)
Expolinc provides 3D models in SketchUp format. These are **not directly convertible to parametric FreeCAD objects**, but are useful as dimensional reference for building the parametric library:
- **SketchUp 3D Warehouse**: `3dwarehouse.sketchup.com/by/expolinc` — official 3D models (.skp)
- **Google Drive** (per product): Each product folder contains a `3D files/` subdirectory
> **Conversion note**: FreeCAD cannot open `.skp` files directly. For reference use, export from SketchUp to Collada (.dae) or OBJ, then import into FreeCAD as a static mesh. The geometry will be non-parametric — use it to verify profile shapes, connector details, and dimensions, then rebuild as FeaturePython parametric objects.
#### Recommended Approach
Do **not** build an automated SketchUp → FreeCAD pipeline. Here's why:
1. **3D Warehouse has no public API** — automated downloading requires scraping (ToS violation)
2. **Even with perfect conversion**, the output is a static "dumb solid" — you cannot change `width` and have geometry regenerate
3. The parametric `FeaturePython` objects that ExpolincLib needs must be **hand-coded** anyway
**Instead, do this:**
1. **Manually download** the SketchUp 3D models from the 3D Warehouse or Google Drive once
2. **Open in SketchUp** (free version) and export as STL
3. **Import into FreeCAD** — Part → Create Shape from Mesh → Convert to Solid → Refine. This gives you a reference solid you can measure
4. **Write the FeaturePython code** manually, using the reference solid for profile cross-sections, connector dimensions, and assembly details
5. **Cross-check dimensions** against the verified weight/size tables from the official website
This produces the parametric library the project actually needs, without the complexity and legal risk of an automated conversion pipeline.
### Verified Data
The weight and size data in this document have been **confirmed accurate** against the official Expolinc website (retrieved 2026-05-30):
| Width × Height | Website | Docs | Match |
|---|---|---|---|
| 0.5 × 2.5 m | 8.3 kg | 8.3 kg | ✓ |
| 0.95 × 2.5 m | 10.5 kg | 10.5 kg | ✓ |
| 1.95 × 2.5 m | 14.5 kg | 14.5 kg | ✓ |
| 2.95 × 2.5 m | 16.5 kg | 16.5 kg | ✓ |
| 3.95 × 2.5 m | 20.4 kg | 20.4 kg | ✓ |
| 4.95 × 2.5 m | 25.0 kg | 25.0 kg | ✓ |
## Specifications (specs.py)
The `specs.py` module contains Expolinc dimensional data and constraints used throughout the library.
```python
# Available sizes
CLASSIC_FRAME_SIZES = {
"widths": [500, 950, 1950, 2950, 3950, 4950], # mm
"heights": [2500, 3000], # mm
}
# Weight tables (kg per component)
CLASSIC_FRAME_WEIGHTS = {
(1950, 2500): 14.5,
(2950, 2500): 16.5,
(3950, 2500): 20.4,
(4950, 2500): 25.0,
(1950, 3000): 18.3,
(2950, 3000): 23.3,
(3950, 3000): 26.3,
(4950, 3000): 28.5,
}
# Material properties
ALUMINUM_PROFILE = {
"material": "AlMgSi0.5 (EN AW-6060)",
"finish": "Silver anodized (E6/EV1)",
"profile_thickness": 1.5, # mm
"frame_depth": 40, # mm
}
```
---
## Layout Functions (layouts.py)
### `build_inline_booth(doc, width, depth, height, **kwargs)`
Creates an inline (row) booth — one back wall with optional side walls.
**Returns:** `dict` with keys `walls`, `connectors`, `accessories`, `bom_data`
### `build_corner_booth(doc, wall_a, wall_b, height, **kwargs)`
Creates a corner booth — two walls at 90° with access from two aisles.
### `build_peninsula_booth(doc, width, depth, height, **kwargs)`
Creates a peninsula booth — U-shaped, open on three sides.
### `build_island_booth(doc, width, depth, height, **kwargs)`
Creates an island booth — four walls, open on all sides.
### `build_custom_booth(doc, wall_specs, **kwargs)`
Creates a booth from a list of wall specifications (arbitrary arrangement).
**Common kwargs:**
| Parameter | Type | Default | Description |
|---|---|---|---|
| `backlit_walls` | list[int] | `[]` | Indices of walls to make backlit |
| `storage_rooms` | list[dict] | `[]` | Storage room config per wall |
| `add_connectors` | bool | `true` | Auto-add connectors between walls |
| `grid_size` | int (mm) | 990 | Layout grid alignment |
---
## BOM Generation (bom.py)
### `generate_bom(doc, format="dict")`
Traverses the FreeCAD document and collects all Expolinc components into a bill of materials.
**Returns format:**
```python
{
"project": "My Booth",
"date": "2026-05-30",
"layout": "island",
"dimensions": {"width": 6000, "depth": 4000, "height": 2500},
"components": [
{
"id": "CF-4950-2500",
"system": "classic_frame",
"type": "wall",
"quantity": 2,
"width": 4950,
"height": 2500,
"weight_kg": 25.0,
"total_weight_kg": 50.0,
},
...
],
"totals": {
"component_count": 12,
"total_weight_kg": 120.5,
"seg_area_m2": 49.5,
"connector_count": {"90deg": 4, "180deg": 0, "T": 0},
"transport_cases": [
{"type": "Standard Case XL", "quantity": 2}
],
}
}
```
### `export_bom_to_csv(doc, filepath)`
Exports BOM to CSV file.
### `export_bom_to_spreadsheet(doc)`
Creates a FreeCAD Spreadsheet object with BOM data in the current document.
docs/INSTALL.md
+187
View File
@@ -0,0 +1,187 @@
# Installation Guide
## Prerequisites
| Requirement | Version | Notes |
|---|---|---|
| **FreeCAD** | 1.0+ | [freecad.org](https://freecad.org) — select Windows (64-bit) installer |
| **Node.js** | 18+ | [nodejs.org](https://nodejs.org) |
| **npm** | 9+ | Ships with Node.js |
| **Git** | — | [git-scm.com](https://git-scm.com) |
| **AI Assistant** | — | Claude Desktop, Claude Code, or any MCP-compatible client |
## Step 1: Install FreeCAD
1. Download FreeCAD 1.0+ from [freecad.org](https://freecad.org/downloads)
2. Run the installer (default options are fine)
3. Verify installation:
```
"C:\Program Files\FreeCAD 1.0\bin\FreeCAD.exe" --version
```
4. Note your FreeCAD user data directory (for adding the ExpolincLib module):
- Windows: `%APPDATA%\FreeCAD\Mod\`
- Linux: `~/.local/share/FreeCAD/Mod/`
- macOS: `~/Library/Application Support/FreeCAD/Mod/`
## Step 2: Install the freecad-mcp Base Server
```bash
git clone https://github.com/sergiudanstan/freecad-mcp.git
cd freecad-mcp
npm install
npm run build
```
Test that it can connect to FreeCAD:
1. Start FreeCAD
2. In FreeCAD, go to **Tools → Addon Manager** and install the freecad-mcp workbench
3. Activate the freecad-mcp workbench from the workbench dropdown
4. Click **Start Server** — you should see: `MCP server listening on port 12345`
5. Back in the terminal:
```bash
node dist/server.js
```
Verify it starts without errors.
## Step 3: Install ExpolincLib
```bash
# Clone the Expolinc Booth Designer repository
git clone https://github.com/your-org/expolinc-booth-designer.git
cd expolinc-booth-designer
# Copy the component library to FreeCAD's Mod directory
# Windows:
copy ExpolincLib "%APPDATA%\FreeCAD\Mod\ExpolincLib\"
# Linux:
# cp -r ExpolincLib ~/.local/share/FreeCAD/Mod/ExpolincLib/
# macOS:
# cp -r ExpolincLib ~/"Library/Application Support/FreeCAD/Mod/ExpolincLib/"
```
Restart FreeCAD. You should see "ExpolincLib" listed in the **Macro → Macros...** menu as available modules.
## Step 4: Install the MCP Server Extension
```bash
cd mcp-server
npm install
npm run build
```
## Step 5: Configure Your AI Assistant
### Claude Desktop
Edit `claude_desktop_config.json` (`%APPDATA%\Claude\` on Windows, `~/Library/Application Support/Claude/` on macOS):
```json
{
"mcpServers": {
"expolinc": {
"command": "node",
"args": [
"C:\\path\\to\\expolinc-booth-designer\\mcp-server\\dist\\server.js"
],
"env": {
"FREECAD_MCP_PORT": "12345",
"EXPOLINC_LIB_PATH": "ExpolincLib"
}
}
}
}
```
### Claude Code
```bash
claude mcp add expolinc node /path/to/expolinc-booth-designer/mcp-server/dist/server.js
```
### VS Code / GitHub Copilot
Add to `.vscode/settings.json` or `.github/copilot/mcp.json`:
```json
{
"mcpServers": {
"expolinc": {
"command": "node",
"args": ["/path/to/expolinc-booth-designer/mcp-server/dist/server.js"],
"env": {
"FREECAD_MCP_PORT": "12345",
"EXPOLINC_LIB_PATH": "ExpolincLib"
}
}
}
}
```
## Step 6: Verify Installation
1. Start FreeCAD and activate the freecad-mcp workbench → **Start Server**
2. Restart your AI assistant
3. Ask:
> *"List available Expolinc systems and components"*
The assistant should call `expolinc_info` and return details about Classic Frame and Light Frame.
4. Try a simple command:
> *"Create a single 1950×2500mm Classic Frame wall"*
The wall should appear in FreeCAD's 3D viewport.
## Windows-Specific Notes
### FreeCAD Installation Paths
Common FreeCAD installation paths on Windows:
| Version | Path |
|---|---|
| FreeCAD 1.0 | `C:\Program Files\FreeCAD 1.0\bin\FreeCAD.exe` |
| FreeCAD 1.1 | `C:\Program Files\FreeCAD 1.1\bin\FreeCAD.exe` |
### FreeCAD Mod Directory
```
%APPDATA%\FreeCAD\Mod\
# Typically resolves to:
C:\Users\<YourUsername>\AppData\Roaming\FreeCAD\Mod\
```
### Environment Variables
The MCP server needs to know where FreeCAD is. If automatic detection fails, set:
```json
"env": {
"FREECAD_PATH": "C:\\Program Files\\FreeCAD 1.0\\bin",
"FREECAD_MCP_PORT": "12345",
"EXPOLINC_LIB_PATH": "ExpolincLib"
}
```
## Headless Mode (Optional)
For batch operations without the FreeCAD GUI, configure the MCP server to use `freecadcmd`:
```json
"env": {
"USE_HEADLESS": "true",
"FREECADCMD_PATH": "C:\\Program Files\\FreeCAD 1.0\\bin\\freecadcmd.exe",
"EXPOLINC_LIB_PATH": "ExpolincLib"
}
```
## Troubleshooting
| Problem | Solution |
|---|---|
| **"Cannot connect to FreeCAD"** | Ensure FreeCAD is running and the freecad-mcp workbench server is started (click **Start Server**) |
| **"ExpolincLib not found"** | Verify ExpolincLib was copied to the correct Mod directory. Check `%APPDATA%\FreeCAD\Mod\ExpolincLib\` |
| **MCP tool not found** | Restart the AI assistant after adding the MCP configuration |
| **Wall positions wrong** | The layout engine uses the 990mm grid (standard exhibition grid). Specify dimensions in multiples of 990mm when possible |
| **Port conflict** | Change `FREECAD_MCP_PORT` in environment variables if port 12345 is already in use |
docs/MCP_TOOLS.md
+386
View File
@@ -0,0 +1,386 @@
# MCP Tools Reference
## Overview
The Expolinc Booth Designer extends the sergiudanstan/freecad-mcp server with **12 custom MCP tools** for designing trade fair booths using Expolinc modular systems. These tools work alongside the server's 165 built-in CAD tools.
## Quick Reference
| Tool | Purpose |
|---|---|
| `expolinc_info` | List available systems, sizes, and components |
| `expolinc_create_wall` | Create a single Classic Frame or Light Frame wall |
| `expolinc_create_corner` | Create a corner connector |
| `expolinc_create_storage` | Create a storage room enclosure |
| `expolinc_create_door` | Add a door to an existing wall |
| `expolinc_build_booth` | Build a complete booth from a layout spec |
| `expolinc_arrange_layout` | Adjust positions of existing wall components |
| `expolinc_add_light_frame` | Convert a wall section to backlit |
| `expolinc_export_bom` | Export bill of materials (CSV/JSON/Spreadsheet) |
| `expolinc_export_step` | Export complete booth as STEP file |
| `expolinc_export_drawing` | Generate dimensioned technical drawing |
| `expolinc_get_component_info` | Get detailed specs for a placed component |
---
## Tool Reference
### `expolinc_info`
Returns available Expolinc systems, component types, and valid size options.
**Parameters:** None
**Example:**
```
User: "What Expolinc components are available?"
Assistant: → calls expolinc_info
```
**Response:**
```json
{
"systems": {
"classic_frame": {
"description": "Modular aluminum frame with SEG fabric graphics",
"available_widths_mm": [500, 950, 1950, 2950, 3950, 4950],
"available_heights_mm": [2500, 3000],
"features": ["tool_free_assembly", "magnetic_connectors", "double_sided"],
"weight_kg": {"1950x2500": 14.5, "4950x2500": 25.0, ...}
},
"light_frame": {
"description": "Backlit LED frame system, integrates with Classic Frame",
"available_widths_mm": [500, 950, 1950, 2950, 3950, 4950],
"available_heights_mm": [2500, 3000],
"led_options": {"temperature_K": [2700, 3000, 4000, 5000, 6500], "brightness_lm": "500-3000"}
}
},
"accessories": ["storage_room", "door", "shelf", "bridge_connector"],
"connectors": ["90_degree", "180_inline", "T_connector"],
"transport_cases": ["basic_box", "travel_set", "standard_case_xl"]
}
```
---
### `expolinc_create_wall`
Creates a single Expolinc wall (Classic Frame or Light Frame) at a specified position.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `width` | number | yes | — | Wall width in mm (500/950/1950/2950/3950/4950) |
| `height` | number | yes | — | Wall height in mm (2500/3000) |
| `system` | string | no | `"classic_frame"` | `"classic_frame"` or `"light_frame"` |
| `position` | object | no | `{"x":0,"y":0,"z":0}` | Wall position (mm) |
| `rotation` | number | no | `0` | Rotation about Z axis in degrees |
| `double_sided` | boolean | no | `false` | Graphic on both sides |
| `finish` | string | no | `"silver"` | Profile finish: `"silver"`, `"white"`, `"black"` |
| `led_temperature` | number | no | `4000` | LED temp in Kelvin (Light Frame only) |
| `led_brightness` | number | no | `1000` | LED brightness in lumens (Light Frame only) |
**Example:**
```
User: "Create a 3950×2500mm Classic Frame wall at position x=0, y=0"
```
**Response:**
```json
{
"success": true,
"component_id": "wall_01",
"type": "classic_frame",
"system": "classic_frame",
"width_mm": 3950,
"height_mm": 2500,
"weight_kg": 20.4,
"position": {"x": 0, "y": 0, "z": 0},
"document": "Booth_001"
}
```
---
### `expolinc_create_corner`
Creates a corner connector.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `angle` | number | no | `90` | Connector angle in degrees (45/90/180) |
| `connector_type` | string | no | `"90_degree"` | `"90_degree"`, `"180_inline"`, `"T_connector"` |
| `position` | object | no | `{"x":0,"y":0,"z":0}` | Position (mm) |
---
### `expolinc_create_storage`
Creates a storage room enclosure.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `width` | number | yes | — | Room width in mm |
| `depth` | number | yes | — | Room depth in mm |
| `height` | number | no | `2500` | Room height in mm |
| `has_door` | boolean | no | `true` | Include door |
| `door_type` | string | no | `"hinged"` | `"hinged"`, `"sliding"` |
| `has_shelving` | boolean | no | `false` | Include shelves |
| `wall_position` | string | no | `"back"` | Which wall to attach to |
---
### `expolinc_create_door`
Adds a door to an existing wall.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `wall_id` | string | yes | — | Component ID of the target wall |
| `width` | number | no | `900` | Door width in mm |
| `height` | number | no | `2200` | Door height in mm |
| `type` | string | no | `"hinged"` | `"hinged"`, `"sliding"`, `"pocket"` |
| `position` | number | no | `"center"` | Horizontal position along wall |
---
### `expolinc_build_booth` (Main Tool)
Builds a complete trade fair booth from a layout specification. This is the primary tool for booth design.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `layout` | string | yes | — | Layout type: `"inline"`, `"corner"`, `"peninsula"`, `"island"`, `"custom"` |
| `width` | number | yes | — | Booth width in mm (inline/peninsula/island) |
| `depth` | number | yes | — | Booth depth in mm (inline/peninsula/island) |
| `height` | number | no | `2500` | Wall height in mm |
| `system` | string | no | `"classic_frame"` | Default wall system |
| `backlit_walls` | number[] | no | `[]` | Wall indices to make backlit (0-indexed) |
| `storage_rooms` | object[] | no | `[]` | Storage room configuration |
| `double_sided` | number[] | no | `[]` | Wall indices to make double-sided |
| `finish` | string | no | `"silver"` | Profile finish |
| `custom_walls` | object[] | no | — | Custom wall definitions (for `custom` layout) |
| `add_connectors` | boolean | no | `true` | Auto-add connectors |
| `name` | string | no | `"Booth"` | Document name |
**Layout-specific wall generation:**
| Layout | Walls Generated | Open Sides |
|---|---|---|
| `inline` | 1 back wall + 2 partial side walls | 1 (front) |
| `corner` | 2 walls at 90° | 2 |
| `peninsula` | 3 walls (U-shape) | 1 (front) |
| `island` | 4 walls (rectangle) | 0 (all sides open) |
**storage_rooms format:**
```json
[
{
"wall_index": 0,
"width": 1950,
"depth": 1000,
"has_door": true,
"door_type": "hinged",
"has_shelving": true
}
]
```
**custom_walls format (for layout="custom"):**
```json
[
{
"width": 3950,
"height": 2500,
"system": "classic_frame",
"position": {"x": 0, "y": 0, "z": 0},
"rotation": 0,
"backlit": false,
"double_sided": false
}
]
```
**Example:**
```
User: "Build a 6x4 meter island booth with 2.5m walls, backlit sections on the front and back, and a storage room on the right wall"
Assistant: → calls expolinc_build_booth with:
layout="island", width=6000, depth=4000, height=2500,
backlit_walls=[0, 2],
storage_rooms=[{"wall_index":1, "width":1950, "depth":1000, "has_door":true}]
```
**Response:**
```json
{
"success": true,
"document": "Booth_Island_6x4",
"layout": "island",
"dimensions": {"width_mm": 6000, "depth_mm": 4000, "height_mm": 2500},
"walls": [
{"id": "wall_00", "width": 6000, "height": 2500, "system": "classic_frame", "backlit": true},
{"id": "wall_01", "width": 4000, "height": 2500, "system": "classic_frame", "has_storage": true},
{"id": "wall_02", "width": 6000, "height": 2500, "system": "classic_frame", "backlit": true},
{"id": "wall_03", "width": 4000, "height": 2500, "system": "classic_frame"}
],
"connectors": 4,
"components": [
{"id": "conn_00", "type": "90_degree", "between": ["wall_00", "wall_01"]},
{"id": "conn_01", "type": "90_degree", "between": ["wall_01", "wall_02"]},
{"id": "conn_02", "type": "90_degree", "between": ["wall_02", "wall_03"]},
{"id": "conn_03", "type": "90_degree", "between": ["wall_03", "wall_00"]},
{"id": "storage_00", "type": "storage_room", "attached_to": "wall_01"}
],
"bom_preview": {
"component_count": 12,
"total_weight_kg": 110.2,
"seg_area_m2": 48.5
}
}
```
---
### `expolinc_arrange_layout`
Adjust the positions and orientations of existing components in the booth.
**Parameters:**
| Parameter | Type | Required | Description |
|---|---|---|---|
| `positions` | object[] | yes | Array of `{component_id, position: {x,y,z}, rotation}` |
---
### `expolinc_add_light_frame`
Converts an existing Classic Frame wall to a Light Frame (backlit) wall, replacing the graphic panel with an LED panel assembly.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `wall_id` | string | yes | — | ID of the wall to convert |
| `led_temperature` | number | no | `4000` | LED temperature in Kelvin |
| `led_brightness` | number | no | `1000` | Brightness in lumens |
---
### `expolinc_export_bom`
Exports the bill of materials for the current booth design.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `format` | string | no | `"json"` | Output format: `"json"`, `"csv"`, `"spreadsheet"` |
| `filepath` | string | no | — | Optional file path for CSV/JSON output |
**Response (JSON format):**
```json
{
"project": "Booth_Island_6x4",
"layout": "island",
"dimensions": {"width_mm": 6000, "depth_mm": 4000, "height_mm": 2500},
"components": [
{"component": "Classic Frame Wall 6000×2500mm", "system": "classic_frame", "qty": 2, "weight_kg": 30.0, "total_kg": 60.0},
{"component": "Classic Frame Wall 4000×2500mm", "system": "classic_frame", "qty": 2, "weight_kg": 22.0, "total_kg": 44.0},
{"component": "Light Frame Conversion 6000×2500mm", "system": "light_frame", "qty": 2, "weight_kg": 5.0, "total_kg": 10.0},
{"component": "90° Corner Connector", "system": "connector", "qty": 4, "weight_kg": 1.5, "total_kg": 6.0},
{"component": "Support Feet (pair)", "system": "accessory", "qty": 8, "weight_kg": 0.8, "total_kg": 6.4},
{"component": "Storage Room 1950×1000×2500mm", "system": "accessory", "qty": 1, "weight_kg": 35.0, "total_kg": 35.0}
],
"totals": {
"component_count": 19,
"total_weight_kg": 161.4,
"seg_area_m2": 48.0,
"walls_light_frame": 2,
"transport_cases": [
{"type": "Standard Case XL", "quantity": 3}
],
"estimated_setup_time_minutes": 45
}
}
```
---
### `expolinc_export_step`
Exports the complete booth assembly as a STEP file.
**Parameters:**
| Parameter | Type | Required | Description |
|---|---|---|---|
| `filepath` | string | yes | Output file path (absolute or relative) |
---
### `expolinc_export_drawing`
Generates a dimensioned technical drawing using FreeCAD's TechDraw workbench.
**Parameters:**
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `format` | string | no | `"pdf"` | Output format: `"pdf"`, `"svg"` |
| `filepath` | string | yes | — | Output file path |
| `views` | string[] | no | `["front","top","right","isometric"]` | Views to include |
| `include_dimensions` | boolean | no | `true` | Include dimension annotations |
---
### `expolinc_get_component_info`
Returns detailed specifications and metadata for a placed component.
**Parameters:**
| Parameter | Type | Required | Description |
|---|---|---|---|
| `component_id` | string | yes | ID of the component to inspect |
---
## Built-in Tools (from freecad-mcp)
The following built-in tools are especially useful when working with Expolinc booths:
| Module | Key Tools |
|---|---|
| **Document** | New, open, save, close, list objects |
| **Import/Export** | STEP, STL, OBJ, DXF, IFC import/export |
| **BIM** | Walls, slabs (for flooring), spaces (for volume calculation) |
| **TechDraw** | Drawing pages, views, dimensions, SVG/PDF export |
| **Spreadsheet** | Create, set cells, formulas (for BOM data) |
| **Part** | Move, rotate, copy, mirror (for manual adjustment) |
## Error Handling
All Expolinc tools return structured error responses:
```json
{
"success": false,
"error": "VALIDATION_ERROR",
"message": "Invalid wall width: 5000mm. Valid widths: 500, 950, 1950, 2950, 3950, 4950mm",
"details": {
"field": "width",
"value": 5000,
"allowed_values": [500, 950, 1950, 2950, 3950, 4950]
}
}
```