Initial commit: REMB - AI-Powered Industrial Estate Master Plan Optimization Engine

.env.example

@@ -0,0 +1,29 @@
+# Environment Configuration for REMB
+
+# Database Configuration
+POSTGRES_USER=remb_user
+POSTGRES_PASSWORD=remb_password
+POSTGRES_SERVER=localhost
+POSTGRES_PORT=5432
+POSTGRES_DB=remb_db
+
+# API Configuration
+API_V1_STR=/api/v1
+PROJECT_NAME="REMB - Industrial Estate Master Planning Engine"
+VERSION=0.1.0
+
+# Optimization Settings
+NSGA2_POPULATION_SIZE=100
+NSGA2_GENERATIONS=200
+NSGA2_CROSSOVER_RATE=0.9
+NSGA2_MUTATION_RATE=0.1
+
+# MILP Solver Settings
+MILP_TIME_LIMIT_SECONDS=3600
+MILP_SOLVER=SCIP
+
+# File Upload Settings
+MAX_UPLOAD_SIZE_MB=50
+
+# Processing Settings
+MAX_CONCURRENT_OPTIMIZATIONS=2

.gitignore

@@ -0,0 +1,86 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+*.manifest
+*.spec
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Virtual Environment
+venv/
+ENV/
+env/
+.venv
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Frontend - Node
+frontend/node_modules/
+frontend/dist/
+frontend/.vite/
+frontend/.cache/
+
+# Logs
+*.log
+logs/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+# Output files
+output/*.dxf
+output/*.pdf
+output/*.png
+!output/.gitkeep
+
+# OS
+Thumbs.db
+.DS_Store
+
+# Temporary files
+*.tmp
+*.temp
+.cache/

config/__init__.py

@@ -0,0 +1 @@
+"""Config package"""

config/regulations.yaml

@@ -0,0 +1,61 @@
+# Vietnamese Industrial Estate Regulations
+# Quy định khu công nghiệp Việt Nam
+
+# Setbacks (khoảng cách lùi ranh giới) - in meters
+setbacks:
+  boundary_minimum: 50  # Khoảng cách tối thiểu từ ranh giới
+  fire_safety_distance: 30  # Khoảng cách an toàn PCCC
+  waterway_buffer: 100  # Vùng đệm sông, suối
+  highway_buffer: 50  # Vùng đệm đường cao tốc
+  residential_buffer: 300  # Khoảng cách từ khu dân cư
+
+# Floor Area Ratio (Tỷ lệ diện tích sàn)
+far:
+  maximum: 0.7  # Hệ số sử dụng đất tối đa
+  minimum: 0.3  # Hệ số sử dụng đất tối thiểu
+
+# Green Space Requirements (Yêu cầu cây xanh)
+green_space:
+  minimum_percentage: 0.15  # 15% diện tích tối thiểu
+  preferred_percentage: 0.20  # 20% diện tích khuyến khích
+
+# Plot Requirements (Yêu cầu lô đất)
+plot:
+  minimum_area_sqm: 1000  # Diện tích lô tối thiểu (m²)
+  maximum_area_sqm: 50000  # Diện tích lô tối đa (m²)
+  minimum_width_m: 20  # Chiều rộng tối thiểu (m)
+  minimum_frontage_m: 15  # Mặt tiền tối thiểu (m)
+
+# Road Network (Mạng lưới đường)
+roads:
+  primary_width_m: 24  # Đường chính
+  secondary_width_m: 16  # Đường nhánh
+  tertiary_width_m: 12  # Đường nội bộ
+  minimum_turning_radius_m: 12  # Bán kính quay đầu tối thiểu
+  maximum_distance_to_road_m: 200  # Khoảng cách tối đa đến đường
+
+# Hazard Zones (Khu vực nguy hiểm)
+hazard_zones:
+  chemical_storage_buffer_m: 200  # Vùng đệm kho hóa chất
+  fuel_storage_buffer_m: 150  # Vùng đệm kho nhiên liệu
+  warehouse_buffer_m: 50  # Vùng đệm kho hàng thường
+  utility_corridor_width_m: 10  # Hành lang kỹ thuật
+
+# Infrastructure (Hạ tầng)
+infrastructure:
+  utility_corridor_percentage: 0.05  # 5% diện tích cho hành lang kỹ thuật
+  drainage_slope_minimum: 0.003  # Độ dốc thoát nước tối thiểu (0.3%)
+  
+# Land Use Distribution (Phân bổ đất đai khuyến nghị)
+land_use:
+  industrial_plots: 0.65  # 65% đất công nghiệp
+  roads_and_infrastructure: 0.20  # 20% đường và hạ tầng
+  green_space: 0.15  # 15% cây xanh
+
+# Optimization Objectives (Mục tiêu tối ưu)
+objectives:
+  weights:
+    sellable_area: 0.5  # Trọng số diện tích có thể bán
+    green_space: 0.2  # Trọng số cây xanh
+    road_efficiency: 0.15  # Trọng số hiệu quả đường
+    regulatory_compliance: 0.15  # Trọng số tuân thủ quy định

config/settings.py

@@ -0,0 +1,50 @@
+"""
+Configuration settings for REMB Optimization Engine
+"""
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    # API Settings
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "REMB - Industrial Estate Master Planning Engine"
+    VERSION: str = "0.1.0"
+    
+    # Database Settings
+    POSTGRES_USER: str = "remb_user"
+    POSTGRES_PASSWORD: str = "remb_password"
+    POSTGRES_SERVER: str = "localhost"
+    POSTGRES_PORT: str = "5432"
+    POSTGRES_DB: str = "remb_db"
+    
+    @property
+    def DATABASE_URL(self) -> str:
+        return f"postgresql://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@{self.POSTGRES_SERVER}:{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
+    
+    # Optimization Settings
+    NSGA2_POPULATION_SIZE: int = 100
+    NSGA2_GENERATIONS: int = 200
+    NSGA2_CROSSOVER_RATE: float = 0.9
+    NSGA2_MUTATION_RATE: float = 0.1
+    
+    # MILP Solver Settings
+    MILP_TIME_LIMIT_SECONDS: int = 3600  # 1 hour
+    MILP_SOLVER: str = "SCIP"  # OR-Tools solver
+    
+    # File Upload Settings
+    MAX_UPLOAD_SIZE_MB: int = 50
+    ALLOWED_EXTENSIONS: list = [".shp", ".dxf", ".geojson"]
+    
+    # Processing Settings
+    MAX_CONCURRENT_OPTIMIZATIONS: int = 2
+    CELERY_BROKER_URL: Optional[str] = None
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+
+settings = Settings()

docs/Core_document.md

@@ -0,0 +1,40 @@
+Cơ chế hoạt động của phần Core Engine theo mô hình "Nhạc trưởng & Kỹ sư" (Orchestrator-Solver Model):
+
+1. Phân chia vai trò
+🧠 LLM (The Brain/Nhạc trưởng): Chịu trách nhiệm hiểu ngữ nghĩa, điều phối luồng đi, xử lý logic nghiệp vụ và giao tiếp với con người. LLM không trực tiếp tính toán hình học.
+
+⚙️ CP Module (The Muscle/Kỹ sư): Chịu trách nhiệm tính toán toán học, giải quyết các ràng buộc hình học (Geometry) và tối ưu hóa (Optimization) chính xác tuyệt đối. CP hoạt động như một "hộp đen" (black-box) xử lý dữ liệu.
+
+2. Quy trình "Bắt tay" (The Handshake Loop)
+Quy trình diễn ra theo vòng lặp khép kín 4 bước:
+
+Dịch (Translation):
+
+LLM nhận yêu cầu tự nhiên (VD: "Tránh kho xăng 200m").
+
+LLM chuyển đổi yêu cầu thành tham số kỹ thuật chuẩn (JSON) để gọi hàm (Function Calling).
+
+Giải (Execution):
+
+CP Module nhận JSON, chạy thuật toán (MILP/GeoPandas).
+
+CP trả về kết quả thô (số liệu, tọa độ) hoặc trạng thái lỗi (nếu bài toán vô nghiệm).
+
+Hiểu (Interpretation):
+
+LLM đọc kết quả thô từ CP.
+
+LLM so sánh với yêu cầu ban đầu để đánh giá: Thành công hay Thất bại.
+
+Quyết định (Reasoning & Action):
+
+Nếu thành công: LLM ra lệnh xuất bản vẽ và báo cáo cho người dùng.
+
+Nếu thất bại (Xung đột): LLM tự động suy luận nguyên nhân (VD: "Quá chật chội"), đề xuất phương án nới lỏng ràng buộc và hỏi ý kiến người dùng.
+
+3. Ưu điểm cốt lõi
+Cơ chế này khắc phục được điểm yếu chết người của từng công nghệ riêng lẻ:
+
+Loại bỏ sự "ảo giác" (hallucination) của AI vì mọi con số đều do CP tính.
+
+Loại bỏ sự "cứng nhắc" của thuật toán truyền thống vì LLM giúp linh hoạt trong việc nhập liệu và xử lý tình huống phát sinh.

docs/MVP-24h.md

@@ -0,0 +1,1783 @@
+# **AIOptimize™ COMPLETE ARCHITECTURE, WORKFLOW & IMPLEMENTATION GUIDE**
+
+## **Enterprise-Ready System Design  Architecture & Strategy** 
+
+**Complete technical architecture, workflow diagrams, technology stack, and implementation strategy**
+
+---
+
+# **🎯 EXECUTIVE OVERVIEW**
+
+## **What This System Does**
+
+AIOptimize™ is an AI-powered industrial estate planning engine that: 1\. Analyzes site boundaries 2\. Generates multiple optimized layout options 3\. Explains optimization choices via AI 4\. Exports professional CAD files
+
+## **System Maturity Levels**
+
+### **Level 1: MVP (6 hours)**
+
+* Basic UI for file upload
+
+* GeoJSON parsing
+
+* Simple visualization
+
+* No optimization
+
+### **Level 2: Smart Demo (12 hours)**
+
+* Real genetic algorithm optimization
+
+* Multiple intelligent layout options
+
+* Hardcoded AI chat explanations
+
+* Professional 2D visualization
+
+### **Level 2+: Enterprise (24 hours)**
+
+* Real Gemini Flash 2.0 AI (replaces hardcoded)
+
+* Professional DXF CAD export
+
+* Complete error handling
+
+* Production-ready deployment
+
+---
+
+# **📊 COMPLETE SYSTEM ARCHITECTURE**
+
+## **High-Level System Design**
+
+┌─────────────────────────────────────────────────────────────┐  
+│                    USER INTERFACE (Browser)                  │  
+│  ┌──────────────┐  ┌────────────────┐  ┌──────────────┐    │  
+│  │  Upload UI   │  │  2D Visualizer │  │  Chat Panel  │    │  
+│  │  (React)     │  │  (Konva.js)    │  │  (React)     │    │  
+│  └──────────────┘  └────────────────┘  └──────────────┘    │  
+│                        │                      │              │  
+│  ┌─────────────────────┴──────────────────────┘              │  
+│  │  Metrics Display │ Export Buttons (DXF/ZIP)              │  
+└──┼──────────────────────────────────────────────────────────┘  
+   │ REST API (HTTP/JSON)  
+   ▼  
+┌─────────────────────────────────────────────────────────────┐  
+│                    APPLICATION BACKEND                       │  
+│                    (FastAPI \- Python)                        │  
+│                                                              │  
+│  ┌──────────────────────────────────────────────────────┐  │  
+│  │  API Layer (REST Endpoints)                          │  │  
+│  │  • /upload-boundary (POST)                          │  │  
+│  │  • /generate-layouts (POST)                         │  │  
+│  │  • /chat (POST)                                     │  │  
+│  │  • /export-dxf (POST)                               │  │  
+│  │  • /export-all-dxf (POST)                           │  │  
+│  │  • /health (GET)                                    │  │  
+│  └──────────────────────────────────────────────────────┘  │  
+│                          │                                   │  
+│  ┌──────────────────────┴───────────────────────────────┐  │  
+│  │          Service Layer (Business Logic)              │  │  
+│  │  ┌──────────────────┐  ┌──────────────────────┐    │  │  
+│  │  │ Geometry Service │  │ GA Optimization      │    │  │  
+│  │  │ (Shapely)        │  │ (Genetic Algorithm)  │    │  │  
+│  │  └──────────────────┘  └──────────────────────┘    │  │  
+│  │  ┌──────────────────┐  ┌──────────────────────┐    │  │  
+│  │  │ Chat Service     │  │ Gemini LLM Service   │    │  │  
+│  │  │ (Hardcoded)      │  │ (Real AI)            │    │  │  
+│  │  └──────────────────┘  └──────────────────────┘    │  │  
+│  │  ���──────────────────┐  ┌──────────────────────┐    │  │  
+│  │  │ DXF Export       │  │ Session Management   │    │  │  
+│  │  │ (ezdxf)          │  │ (In-memory store)    │    │  │  
+│  │  └──────────────────┘  └──────────────────────┘    │  │  
+│  └──────────────────────────────────────────────────────┘  │  
+│                                                              │  
+│  ┌──────────────────────────────────────────────────────┐  │  
+│  │  Data Layer                                          │  │  
+│  │  • Session storage (UUID → site data)               │  │  
+│  │  • Geometry data (Shapely Polygon objects)          │  │  
+│  │  • Layout options (plot coordinates, metrics)       │  │  
+│  │  • Export cache (temporary DXF files)               │  │  
+│  └──────────────────────────────────────────────────────┘  │  
+└─────────────────────────────────────────────────────────────┘  
+   │ External API Calls  
+   ├─→ Google Gemini API (AI Chat)  
+   ├─→ GeoJSON parsing (geospatial data)  
+   └─→ File system (export storage)
+
+---
+
+# **🏗️ DETAILED SYSTEM COMPONENTS**
+
+## **Component 1: Frontend Application Layer**
+
+### **Purpose**
+
+Interactive user interface for site analysis and visualization.
+
+### **Responsibilities**
+
+* File upload handling
+
+* 2D site visualization
+
+* Layout options display
+
+* Chat interface
+
+* Export button management
+
+* Real-time state management
+
+### **Technology Choices & Why**
+
+* **React** (instead of Vue/Angular)
+
+  * Large ecosystem (tools, libraries, components)
+
+  * TypeScript support (type safety)
+
+  * Easier learning curve for full-stack developers
+
+  * Better component reusability
+
+* **TypeScript** (instead of plain JavaScript)
+
+  * Catches errors at compile time
+
+  * Better IDE support and autocomplete
+
+  * Self-documenting code
+
+  * Enterprise standard
+
+* **Konva.js** (instead of Canvas API / D3 / Three.js)
+
+  * Specifically built for 2D graphics
+
+  * Simpler API than raw Canvas
+
+  * Built-in event handling
+
+  * Better performance for GIS visualization
+
+* **Axios** (instead of Fetch API / GraphQL)
+
+  * Simpler request/response handling
+
+  * Built-in interceptors (error handling, logging)
+
+  * Request/response transformation
+
+  * Backward compatible
+
+* **Lucide React** (for icons)
+
+  * Lightweight icon library
+
+  * Consistent icon set
+
+  * Simple integration with React
+
+### **Data Flow (Frontend)**
+
+User Action (Upload/Generate/Chat)  
+    ↓  
+React State Update  
+    ↓  
+API Call via Axios  
+    ↓  
+Wait for Response  
+    ↓  
+Update UI Components  
+    ↓  
+Display Results
+
+### **Component Hierarchy**
+
+\<App\> (Main)  
+├─ Header (Logo, Title)  
+├─ FileUploadPanel  
+│  ├─ Upload Button  
+│  └─ Sample Data Button  
+├─ MainContent (60% width)  
+│  ├─ Map2DPlotter (Konva Stage)  
+│  │  ├─ Boundary Polygon  
+│  │  ├─ Setback Zone  
+│  │  └─ Grid/Reference Lines  
+│  ├─ LayoutOptionsPanel  
+│  │  ├─ OptionCard 1  
+│  │  ├─ OptionCard 2  
+│  │  └─ OptionCard 3  
+│  └─ ExportPanel  
+│     ├─ Export Individual Buttons  
+│     └─ Export All Zip Button  
+└─ ChatSidebar (40% width)  
+   └─ ChatInterface  
+      ├─ Message History  
+      ├─ Message Input  
+      └─ Send Button
+
+---
+
+## **Component 2: Backend Application Layer**
+
+### **Purpose**
+
+Business logic, optimization algorithms, and data processing.
+
+### **Responsibilities**
+
+* REST API endpoint management
+
+* GeoJSON parsing and validation
+
+* Session management
+
+* Genetic algorithm execution
+
+* AI response generation
+
+* DXF file creation
+
+* Error handling and logging
+
+### **Technology Choices & Why**
+
+* **FastAPI** (instead of Flask / Django / Starlette)
+
+  * Automatic OpenAPI documentation
+
+  * Built-in request validation (Pydantic)
+
+  * Asynchronous support (async/await)
+
+  * Type hints integration
+
+  * Very fast (ASGI-based)
+
+  * Smaller learning curve than Django
+
+* **Python 3.8+** (language choice)
+
+  * Large scientific computing ecosystem
+
+  * Quick prototyping and development
+
+  * Strong geospatial libraries (Shapely, GeoPandas)
+
+  * Good AI/ML library support
+
+  * Easy deployment
+
+* **Shapely** (instead of GDAL / PostGIS / Turf.js)
+
+  * Pure Python (no native dependencies)
+
+  * Simple geometry operations
+
+  * Built-in validation
+
+  * Good performance for 2D operations
+
+  * Well-documented
+
+* **NumPy** (for numerical operations)
+
+  * Industry standard for numerical computing
+
+  * Fast matrix/array operations
+
+  * Genetic algorithm fitness calculations
+
+  * Statistical functions
+
+* **google-generativeai** (for Gemini API)
+
+  * Official Google library
+
+  * Maintained and updated
+
+  * Simple API for chat completion
+
+  * Free tier available
+
+* **ezdxf** (instead of pyDXF / cadquery / LibreCAD)
+
+  * Comprehensive DXF support (R2010 standard)
+
+  * Specific for CAD file creation
+
+  * Active maintenance
+
+  * Good layer/attribute support
+
+  * Works with all CAD software
+
+### **Service Architecture**
+
+API Layer (REST Endpoints)  
+    ↓  
+    ├─ Authentication/Validation  
+    ├─ Request Routing  
+    └─ Response Formatting  
+    ↓  
+Service Layer (Business Logic)  
+    ├─ GeometryService  
+    │  ├─ Parse GeoJSON → Polygon  
+    │  ├─ Calculate setback zones  
+    │  ├─ Validate boundaries  
+    │  └─ Compute metrics  
+    │  
+    ├─ OptimizationService  
+    │  ├─ Genetic Algorithm  
+    │  ├─ Population management  
+    │  ├─ Fitness evaluation  
+    │  └─ Layout generation  
+    │  
+    ├─ ChatService  
+    │  ├─ Message analysis  
+    │  ├─ Response generation  
+    │  └─ Context management  
+    │  
+    ├─ GeminiService  
+    │  ├─ API communication  
+    │  ├─ Prompt engineering  
+    │  └─ Error handling  
+    │  
+    └─ ExportService  
+       ├─ DXF document creation  
+       ├─ Layer management  
+       └─ File export
+
+    ↓  
+Data Layer (Storage & Access)  
+    ├─ Session Store (In-memory)  
+    ├─ File System (Export cache)  
+    └─ External APIs (Gemini, etc.)
+
+---
+
+## **Component 3: Optimization Algorithm (Genetic Algorithm)**
+
+### **Purpose**
+
+Generate multiple intelligent layout options that maximize different objectives.
+
+### **How It Works (Conceptual)**
+
+**Phase 1: Initialization** \- Create 10 random layout candidates \- Each layout has 8 plots positioned randomly within boundary \- Each plot respects 50m setback rule
+
+**Phase 2: Evaluation** \- Calculate fitness score for each layout \- Fitness \= (Profit Score × 0.5) \+ (Compliance Score × 0.3) \+ (Space Efficiency × 0.2) \- Profit \= total plot area (more area \= higher profit) \- Compliance \= 1.0 if all setback rules met, 0.8 if violated \- Space Efficiency \= (used area / total boundary area)
+
+**Phase 3: Selection** \- Keep top 3 best performers (elitism) \- Discard bottom 7 layouts
+
+**Phase 4: Reproduction** \- Create 7 new layouts from the elite 3 \- New layouts are mutations of elite layouts \- 30% of plots in each new layout are randomly repositioned
+
+**Phase 5: Mutation** \- Randomly adjust plot positions (±30 meters) \- Small probability of adding/removing plots \- Ensures genetic diversity
+
+**Phase 6: Repeat** \- Run phases 2-5 for 20 generations \- Track best solution from each generation \- Stop if improvement plateaus
+
+**Result: Top 3 layouts with different strategies** \- Option 1: Maximum profit (most plots) \- Option 2: Balanced (medium plots, more space) \- Option 3: Premium (fewer plots, larger sizes)
+
+### **Why Genetic Algorithm?**
+
+| Approach | Pros | Cons | Used Here? |
+| :---- | :---- | :---- | :---- |
+| Random Search | Simple | Very slow (1000s of tries) | ❌ |
+| Greedy Algorithm | Fast | Gets stuck in local optimum | ❌ |
+| Simulated Annealing | Good for some problems | Limited diversity | ❌ |
+| **Genetic Algorithm** | **Finds diverse solutions** | **Reasonable time** | ✅ |
+| Linear Programming | Optimal solutions | Complex setup | ❌ |
+
+### **Algorithm Parameters (Tuned for Demo)**
+
+| Parameter | Value | Reason |
+| :---- | :---- | :---- |
+| Population Size | 10 | Balance speed vs. diversity |
+| Generations | 20 | Enough iterations for convergence |
+| Elite Size | 3 | Keep best performers |
+| Mutation Rate | 0.3 (30%) | Enough randomness for diversity |
+| Target Plots | 8 | Realistic for industrial estates |
+| Setback Distance | 50m | Typical zoning requirement |
+
+---
+
+## **Component 4: AI Chat System**
+
+### **Level 2: Hardcoded Responses**
+
+**How it works:** 1\. User asks question 2\. Analyze question keywords 3\. Match to predefined category 4\. Return scripted response
+
+**Categories:** \- Layout differences → Explain trade-offs \- Best option → Recommend based on fitness scores \- Compliance questions → Explain setback rules \- Metrics questions → Define each metric \- Algorithm questions → Explain GA process \- Default → Generic helpful response
+
+**Advantages:** \- Fast response (no API latency) \- Completely free \- Predictable behavior \- Works offline
+
+**Disadvantages:** \- Rigid responses (no true understanding) \- Limited conversational ability \- Can’t handle new question types
+
+### **Level 2+: Real Gemini LLM**
+
+**How it works:** 1\. User asks question 2\. Build context from current layouts 3\. Send to Google Gemini API 4\. Get intelligent response 5\. Return response to user 6\. Fall back to hardcoded if API fails
+
+**Advantages:** \- Real AI understanding \- Handles unlimited question variations \- Context-aware responses \- Professional appearance
+
+**Disadvantages:** \- API latency (1-2 seconds) \- Requires internet connection \- Rate-limited free tier \- Costs money at scale
+
+**Gemini Choice Rationale:**
+
+| Provider | Cost | Speed | Quality | Integration | Chosen? |
+| :---- | :---- | :---- | :---- | :---- | :---- |
+| OpenAI GPT-4 | $$$ (expensive) | Fast | Best | Simple | ❌ || Anthropic Claude | $$ (moderate) | Slower | Very Good | Simple | ❌ |
+| **Google Gemini** | **FREE** | **Fast** | **Good** | **Simple** | ✅ |
+| Open Source (LLaMA) | Free | Slow | OK | Complex | ❌ |
+| Self-hosted LLM | Free | Slow | OK | Complex | ❌ |
+
+**Why Gemini Flash 2.0 specifically:** \- Free tier: 15 requests/minute, 1.5M tokens/day \- Fast: \<1 second response time \- Latest: Up-to-date training (knowledge cutoff 2024\) \- Reliable: Google infrastructure \- Easy: Simple Python library
+
+---
+
+## **Component 5: CAD Export System**
+
+### **Purpose**
+
+Create professional, industry-standard CAD files for architects and planners.
+
+### **DXF Format Choice Rationale**
+
+| Format | Use Case | Pros | Cons | Chosen? |
+| :---- | :---- | :---- | :---- | :---- |
+| PDF | Drawings, reports | Universal | Not editable | ❌ |
+| **DXF** | **CAD software** | **Universal, editable** | **Old format** | ✅ |
+| SVG | Web graphics | Modern, scalable | Limited CAD support | ❌ |
+| GeoJSON | Geospatial data | Standard, portable | Not CAD format | ❌ |
+| AutoCAD DWG | Professional | Industry standard | Proprietary, paid | ❌ |
+
+**DXF Advantages:** \- Open standard (40+ years old) \- Works with all CAD software (AutoCAD, LibreCAD, DraftSight, etc.) \- Works with free online viewers \- Professional appearance \- Contains all necessary information
+
+### **DXF File Structure**
+
+DXF Document  
+├─ Header (Version, units, etc.)  
+├─ Layers (Organizational hierarchy)  
+│  ├─ BOUNDARY (Site edge \- black, solid)  
+│  ├─ SETBACK (50m buffer zone \- red, dashed)  
+│  ├─ PLOTS (Individual plots \- cyan, solid)  
+│  ├─ LABELS (Plot names P1,P2,etc. \- white)  
+│  ├─ ANNOTATIONS (Area labels 1200m² \- yellow)  
+│  └─ TITLEBLOCK (Metadata \- black)  
+├─ Entities (Drawing elements)  
+│  ├─ Polylines (Plot boundaries)  
+│  ├─ Circles (Reference points)  
+│  ├─ Text (Labels and annotations)  
+│  └─ Lines (Grid, dimensions)  
+└─ Blocks (Reusable components)
+
+### **Export Options**
+
+**Option 1: Single Layout Export** \- Download individual DXF file \- Filename: option\_1\_20251204\_123456.dxf \- \~50-100KB file size \- Immediate download
+
+**Option 2: All Layouts ZIP** \- Download ZIP containing 3 DXF files \- Filename: layouts\_20251204\_123456.zip \- \~150-300KB total \- Immediate download \- User extracts to get individual files
+
+### **Why ezdxf Library?**
+
+| Library | Purpose | Pros | Cons | Chosen? |
+| :---- | :---- | :---- | :---- | :---- |
+| **ezdxf** | **DXF creation** | **Complete, Python native** | **Not for plotting** | ✅ |
+| pyDXF | DXF creation | Lightweight | Limited features | ❌ |
+| CADQuery | CAD design | Parametric | Heavy (depends on OpenCASCADE) | ❌ |
+| GDAL | Geospatial I/O | Comprehensive | Complex | ❌ |
+| Inkscape | Vector graphics | GUI-based | Not programmable | ❌ |
+
+**ezdxf Advantages:** \- Pure Python (no native dependencies) \- Complete DXF R2010 support \- Easy layer management \- Good performance \- Well-documented \- Active maintenance
+
+---
+
+# **🔄 COMPLETE WORKFLOW (USER PERSPECTIVE)**
+
+## **User Journey \- Step by Step**
+
+### **Step 1: Upload Site Boundary**
+
+User Action: Click "Upload" button and select GeoJSON file  
+    ↓  
+Frontend: Read file using FileReader API  
+    ↓  
+Frontend: Send to backend /api/upload-boundary endpoint  
+    ↓  
+Backend: Parse GeoJSON  
+    \- Extract coordinates  
+    \- Create Shapely Polygon  
+    \- Validate geometry (is\_valid check)  
+    \- Create session with UUID  
+    \- Store in memory  
+    ↓  
+Backend: Return session\_id \+ boundary coordinates \+ metadata  
+    ↓  
+Frontend: Store session\_id in React state  
+    ↓  
+Frontend: Extract boundary coordinates  
+    ↓  
+Frontend: Render on 2D canvas using Konva  
+    \- Create Polygon shape  
+    \- Set scale to fit canvas  
+    \- Render with black line (1px)  
+    \- Add reference grid  
+    ↓  
+User Sees: 2D plot of site boundary with dimensions (area, perimeter)
+
+### **Step 2: Generate Optimized Layouts**
+
+User Action: Click "Generate Layouts" button  
+    ↓  
+Frontend: Make POST request to /api/generate-layouts with session\_id  
+    ↓  
+Backend: Retrieve session using session\_id  
+    ↓  
+Backend: Initialize Genetic Algorithm  
+    \- Create population of 10 random layouts  
+    \- Each layout has 8 plots  
+    \- Each plot respects 50m setback  
+    ↓  
+Backend: Run GA evolution loop (20 generations)  
+    For each generation:  
+    1\. Evaluate fitness of all 10 layouts  
+    2\. Select top 3 (elitism)  
+    3\. Create 7 new layouts from elite (mutation)  
+    4\. Replace population  
+    ↓  
+Backend: Extract top 3 final layouts  
+    ↓  
+Backend: Calculate metrics for each layout  
+    \- Total plots count  
+    \- Total area (sum of plot areas)  
+    \- Average plot size  
+    \- Fitness score  
+    ↓  
+Backend: Return options array with plot data \+ metrics  
+    ↓  
+Frontend: Receive options data  
+    ↓  
+Frontend: Render 3 option cards  
+    \- Each card shows option name (Option 1/2/3)  
+    \- Display icon (💰/⚖️/🏢)  
+    \- Show metrics (plots, area, avg, fitness)  
+    \- Show compliance status (PASS)  
+    ↓  
+User Sees: 3 layout options with different characteristics
+
+### **Step 3: Ask Chat Questions**
+
+User Action: Type question in chat input, press Enter  
+    ↓  
+Frontend: Add user message to message history  
+    ↓  
+Frontend: Send POST to /api/chat with session\_id \+ message  
+    ↓  
+Backend: Receive question \+ session data  
+    ↓  
+Backend: Check if Gemini API available  
+    ├─ YES: Call GeminiService  
+    │   \- Build context from current layouts  
+    │   \- Create prompt with system instructions  
+    │   \- Send to Google Gemini API  
+    │   \- Get response  
+    │   \- Return with model="gemini-2.0-flash"  
+    │  
+    └─ NO: Use fallback ChatService  
+        \- Analyze question keywords  
+        \- Match to category  
+        \- Return scripted response  
+        \- Return with model="fallback"  
+    ↓  
+Frontend: Receive response \+ model type  
+    ↓  
+Frontend: Add assistant message to chat  
+    ↓  
+Frontend: Display model indicator badge  
+    \- "🤖 Powered by Gemini" if real AI  
+    \- "💬 Fallback Mode" if hardcoded  
+    ↓  
+Frontend: Auto-scroll to show latest message  
+    ↓  
+User Sees: AI response explaining the layouts
+
+### **Step 4: Export to CAD**
+
+User Action: Click "Option 1 DXF" button  
+    ↓  
+Frontend: Make POST to /api/export-dxf with session\_id \+ option\_id  
+    ↓  
+Backend: Retrieve layout from session  
+    ↓  
+Backend: Call DXFExportService  
+    ├─ Create new DXF document  
+    ├─ Setup layers (BOUNDARY, SETBACK, PLOTS, etc.)  
+    ├─ Draw site boundary polygon  
+    ├─ Draw 50m setback zone  
+    ├─ Draw each plot rectangle  
+    ├─ Add plot labels (P1, P2, etc.)  
+    ├─ Add area annotations  
+    ├─ Add title block with metadata  
+    └─ Save to temporary file  
+    ↓  
+Backend: Stream DXF file to frontend as blob  
+    ↓  
+Frontend: Create blob from response  
+    ↓  
+Frontend: Create temporary download link  
+    ↓  
+Frontend: Trigger browser download  
+    \- Filename: option\_1\_20251204\_123456.dxf  
+    \- MIME type: application/x-autocad-dxf  
+    ↓  
+Browser: Downloads file to user's Downloads folder  
+    ↓  
+User Can: Open in AutoCAD, LibreCAD, or online viewers
+
+### **Step 5: Export All as ZIP**
+
+User Action: Click "Export All as ZIP" button  
+    ↓  
+Frontend: Make POST to /api/export-all-dxf with session\_id  
+    ↓  
+Backend: Get all 3 layouts from session  
+    ↓  
+Backend: For each layout:  
+    \- Call DXFExportService  
+    \- Generate DXF file  
+    \- Add to ZIP archive  
+    ↓  
+Backend: Create ZIP file containing 3 DXF files  
+    ↓  
+Backend: Stream ZIP to frontend  
+    ↓  
+Frontend: Trigger browser download  
+    \- Filename: layouts\_20251204\_123456.zip  
+    \- MIME type: application/zip  
+    ↓  
+User Can: Unzip and open each DXF in CAD software
+
+---
+
+# **🛠️ COMPLETE TECHNOLOGY STACK**
+
+## **Frontend Stack**
+
+### **Core Framework**
+
+* **React 18** \- UI library
+
+  * Component-based architecture
+
+  * Virtual DOM optimization
+
+  * Hooks for state management
+
+  * Functional components
+
+* **TypeScript 5** \- Type safety
+
+  * Type checking at compile time
+
+  * Better IDE support
+
+  * Self-documenting
+
+  * Catches errors early
+
+### **UI & Visualization**
+
+* **Konva.js** \- 2D Canvas library
+
+  * Stage (canvas container)
+
+  * Layers (grouping elements)
+
+  * Shapes (Polygon, Rect, Text)
+
+  * Event handling
+
+  * Performance optimization
+
+* **Lucide React** \- Icon library
+
+  * Upload, Download, Zap, MessageCircle icons
+
+  * Lightweight (SVG-based)
+
+  * Consistent styling
+
+* **CSS/Styling**
+
+  * Inline styles (React style objects)
+
+  * Tailwind CSS (optional)
+
+  * CSS Flexbox/Grid for layout
+
+  * Responsive design media queries
+
+### **Data & Communication**
+
+* **Axios** \- HTTP client
+
+  * REST API calls
+
+  * Request/response handling
+
+  * Error handling
+
+  * Request interceptors
+
+* **React Hooks** \- State management
+
+  * useState (component state)
+
+  * useEffect (side effects)
+
+  * useRef (direct DOM access)
+
+  * useCallback (memoization)
+
+### **Build & Development**
+
+* **Create React App** \- Build tool
+
+  * Webpack configuration
+
+  * Babel transpiling
+
+  * Development server
+
+  * Production optimization
+
+* **npm** \- Package manager
+
+  * Dependency management
+
+  * Version control
+
+  * Scripts execution
+
+### **Browser APIs Used**
+
+* **FileReader API** \- File upload handling
+
+* **Fetch API** / Axios \- HTTP requests
+
+* **Blob API** \- File downloads
+
+* **LocalStorage** \- Session persistence (optional)
+
+---
+
+## **Backend Stack**
+
+### **Core Framework**
+
+* **FastAPI** \- Web framework
+
+  * ASGI (async support)
+
+  * Automatic API documentation
+
+  * Request validation (Pydantic)
+
+  * Type hints integration
+
+  * Middleware support
+
+* **Python 3.8+** \- Language
+
+  * Type hints
+
+  * Async/await support
+
+  * Rich ecosystem
+
+  * Easy deployment
+
+### **Geospatial & Geometry**
+
+* **Shapely** \- Geometry operations
+
+  * Polygon creation from coordinates
+
+  * Buffer operations (setback zones)
+
+  * Geometry validation
+
+  * Intersection/containment checks
+
+  * Distance calculations
+
+* **NumPy** \- Numerical computing
+
+  * Array operations
+
+  * Mathematical functions
+
+  * Random number generation
+
+  * Statistical calculations
+
+* **GeoJSON** \- Data format
+
+  * Standard geospatial format
+
+  * JSON-based
+
+  * Supported by most GIS tools
+
+  * Web-friendly
+
+### **Optimization**
+
+* **Genetic Algorithm** (custom implementation)
+
+  * Population management
+
+  * Fitness calculation
+
+  * Selection operators
+
+  * Crossover/mutation
+
+  * Convergence detection
+
+### **AI & LLM**
+
+* **google-generativeai** \- Gemini API client
+
+  * Chat completion
+
+  * Context window management
+
+  * Token counting
+
+  * Error handling
+
+### **CAD & Export**
+
+* **ezdxf** \- DXF file creation
+
+  * Document creation
+
+  * Layer management
+
+  * Entity creation (polylines, text)
+
+  * Attributes and styling
+
+  * File output
+
+### **Utilities**
+
+* **python-multipart** \- File upload handling
+
+* **python-dotenv** \- Environment variables (.env)
+
+* **uvicorn** \- ASGI server
+
+  * Production-ready
+
+  * Hot reload (development)
+
+  * Multiple worker support
+
+### **Package Management**
+
+* **pip** \- Python package manager
+
+* **requirements.txt** \- Dependency specification
+
+* **Virtual environment** \- Isolation
+
+---
+
+## **DevOps & Infrastructure**
+
+### **Development**
+
+* **Local Development Server**
+
+  * Backend: uvicorn (localhost:8000)
+
+  * Frontend: npm (localhost:3000)
+
+  * CORS enabled for local testing
+
+### **Version Control**
+
+* **Git** \- Source control
+
+  * Code tracking
+
+  * Collaboration
+
+  * Version history
+
+* **GitHub** \- Repository hosting
+
+  * Remote backup
+
+  * CI/CD integration
+
+  * Collaboration features
+
+### **Deployment Targets**
+
+#### *Frontend Deployment*
+
+* **Vercel** (recommended for React)
+
+  * Git integration
+
+  * Automatic deployments
+
+  * Global CDN
+
+  * Environment variables
+
+  * Free tier available
+
+* **Netlify** (alternative)
+
+  * Similar features
+
+  * Lambda functions (optional)
+
+  * Form handling
+
+#### *Backend Deployment*
+
+* **Railway** (recommended for Python)
+
+  * Docker support
+
+  * Git integration
+
+  * Automatic deployments
+
+  * PostgreSQL addon available
+
+  * Free tier available
+
+* **Heroku** (alternative)
+
+  * Python support
+
+  * Addons (database, etc.)
+
+  * Procfile configuration
+
+  * Paid only
+
+* **AWS / Google Cloud / Azure**
+
+  * More complex setup
+
+  * More control
+
+  * Pay-as-you-go pricing
+
+  * Enterprise scale
+
+### **Database (Future Enhancement)**
+
+* **PostgreSQL** \- Relational database
+
+  * Project persistence
+
+  * User data storage
+
+  * PostGIS extension (geospatial queries)
+
+* **Redis** \- Caching (optional)
+
+  * Session caching
+
+  * Job queue
+
+  * Rate limiting
+
+---
+
+# **📋 SYSTEM REQUIREMENTS & SPECIFICATIONS**
+
+## **Frontend Requirements**
+
+### **Browser Compatibility**
+
+* Chrome 90+
+
+* Firefox 88+
+
+* Safari 14+
+
+* Edge 90+
+
+### **Minimum System Specs**
+
+* 1GB RAM
+
+* Modern CPU (2010+)
+
+* 50MB disk space
+
+* Broadband internet (2+ Mbps)
+
+### **Screen Resolutions Supported**
+
+* Desktop: 1024x768 minimum (1920x1080 optimal)
+
+* Tablet: 768x1024 minimum
+
+* Mobile: 320x480 (basic support)
+
+### **Network Requirements**
+
+* HTTPS for production
+
+* CORS enabled
+
+* WebSocket support (optional, for future features)
+
+---
+
+## **Backend Requirements**
+
+### **Server Specs (Minimum)**
+
+* **CPU**: 1 core
+
+* **RAM**: 512MB
+
+* **Disk**: 2GB
+
+* **Network**: Broadband (10+ Mbps)
+
+### **Python Version**
+
+* 3.8+ required
+
+* 3.10+ recommended
+
+### **Operating System**
+
+* Linux (production)
+
+* macOS (development)
+
+* Windows 10+ (development)
+
+### **Dependencies**
+
+* FastAPI
+
+* Shapely
+
+* NumPy
+
+* google-generativeai
+
+* ezdxf
+
+* python-multipart
+
+* python-dotenv
+
+* uvicorn
+
+---
+
+# **🔐 SECURITY CONSIDERATIONS**
+
+## **Frontend Security**
+
+### **File Upload Security**
+
+* Validate file type (only .geojson, .json)
+
+* Limit file size (5MB maximum)
+
+* No executable file types
+
+* Scan for malicious content (optional)
+
+### **API Communication**
+
+* Use HTTPS only
+
+* CORS validation
+
+* Input validation before sending
+
+* Sanitize displayed content
+
+### **Data Privacy**
+
+* No sensitive data stored locally
+
+* Use httpOnly cookies (if session tokens used)
+
+* Clear session on logout
+
+* Implement CSP headers
+
+---
+
+## **Backend Security**
+
+### **Input Validation**
+
+* Validate GeoJSON format
+
+* Check coordinate bounds
+
+* Validate session IDs
+
+* Check file paths (prevent directory traversal)
+
+### **API Security**
+
+* Rate limiting (to prevent abuse)
+
+* CORS restrictions (whitelist allowed origins)
+
+* Input sanitization
+
+* Error handling (no sensitive info in errors)
+
+### **Authentication (Future)**
+
+* API keys for external access
+
+* User authentication (OAuth2/JWT)
+
+* Role-based access control
+
+* Audit logging
+
+### **AI API Security**
+
+* Store GEMINI\_API\_KEY in environment variables
+
+* Never commit keys to Git
+
+* Rotate keys periodically
+
+* Monitor API usage
+
+* Set spending limits
+
+### **File Handling**
+
+* Validate DXF file paths
+
+* Use secure temporary directories
+
+* Auto-delete old export files
+
+* Limit export directory size
+
+---
+
+# **⚡ PERFORMANCE OPTIMIZATION STRATEGIES**
+
+## **Frontend Optimization**
+
+### **Code Splitting**
+
+* Lazy load components
+
+* Code splitting by route
+
+* Dynamic imports for heavy libraries
+
+### **Asset Optimization**
+
+* Minify JavaScript/CSS
+
+* Compress images
+
+* Use WebP format
+
+* Cache static assets
+
+### **Rendering Optimization**
+
+* Memoize expensive components
+
+* Virtual scrolling for large lists
+
+* Debounce resize events
+
+* Optimize Konva rendering
+
+### **Bundle Size**
+
+* Tree-shaking unused code
+
+* Remove development dependencies
+
+* Use production builds
+
+* Monitor with webpack-bundle-analyzer
+
+---
+
+## **Backend Optimization**
+
+### **Algorithm Optimization**
+
+* GA parameters tuned for performance
+
+* Early termination if converged
+
+* Parallel population evaluation (optional)
+
+* Caching of fitness calculations
+
+### **API Optimization**
+
+* Pagination for large responses
+
+* Compression (gzip)
+
+* Caching headers
+
+* Connection pooling
+
+### **Memory Optimization**
+
+* Session cleanup (remove old sessions)
+
+* Stream large file downloads
+
+* Limit file size
+
+* Garbage collection tuning
+
+### **Database Optimization (Future)**
+
+* Indexes on frequently queried fields
+
+* Query optimization
+
+* Connection pooling
+
+* Replication for redundancy
+
+---
+
+# **🔄 DATA FLOW & STATE MANAGEMENT**
+
+## **Frontend State Management**
+
+### **React State Hierarchy**
+
+App (Root)  
+├─ sessionId (string, UUID)  
+├─ boundary (GeoJSON polygon)  
+├─ options (array of layout options)  
+├─ siteMetadata (object: area, perimeter)  
+├─ messages (array of chat messages)  
+├─ loading (boolean, for loading states)  
+└─ errors (array of error messages)
+
+### **State Updates**
+
+User Action  
+    ↓  
+Event Handler (onClick, onChange, etc.)  
+    ↓  
+Call setState or useReducer  
+    ↓  
+Trigger re-render of affected components  
+    ↓  
+Virtual DOM diff  
+    ↓  
+Update actual DOM  
+    ↓  
+Display changes to user
+
+---
+
+## **Backend Session Management**
+
+### **Session Lifecycle**
+
+User Uploads File  
+    ↓  
+Backend creates Session object  
+    \- Generate UUID  
+    \- Store in memory dictionary  
+    \- Initialize with empty data  
+    ↓  
+Return session\_id to frontend  
+    ↓  
+Frontend stores session\_id in state  
+    ↓  
+All subsequent requests include session\_id  
+    ↓  
+Backend retrieves session from dictionary  
+    ↓  
+Add/update session data (layouts, metadata)  
+    ↓  
+Session remains available for 24 hours (optional cleanup)  
+    ↓  
+User closes browser/session expires  
+    ↓  
+Backend periodically cleans up old sessions
+
+---
+
+# **📊 INTEGRATION POINTS & DEPENDENCIES**
+
+## **External Services**
+
+### **Google Gemini API**
+
+* **Purpose**: Real AI chat responses
+
+* **Integration**: google-generativeai Python library
+
+* **Authentication**: API key in environment variable
+
+* **Rate Limits**: 15 requests/minute (free tier)
+
+* **Fallback**: Use hardcoded responses if unavailable
+
+### **GeoJSON Input**
+
+* **Source**: User file upload
+
+* **Format**: RFC 7946 standard
+
+* **Validation**: Shapely geometry checks
+
+* **Expected Data**: Polygon geometry (site boundary)
+
+### **File System**
+
+* **Purpose**: Store temporary export files
+
+* **Location**: backend/exports/ directory
+
+* **Cleanup**: Remove files older than 24 hours
+
+* **Permissions**: Read/write/delete
+
+---
+
+# **📈 SCALABILITY & GROWTH PATH**
+
+## **Current System (Single Server)**
+
+Frontend (Vercel CDN)  
+    ↓ HTTPS  
+Backend (Single Railway container)  
+    └─ All processing  
+    └─ In-memory session storage  
+    └─ Temporary file storage
+
+### **Limitations**
+
+* \~100 concurrent sessions
+
+* \~1000 requests/minute
+
+* Data lost on restart
+
+* No redundancy
+
+---
+
+## **Future: Scalable Architecture**
+
+                                    External  
+                                    Services  
+                                    (Gemini)  
+                                        ↑  
+User (Browser)                          │  
+    ↓ HTTPS                            │  
+    └─ Vercel CDN ←──────────────────┬─┘  
+                        ↓  
+                    Load Balancer  
+                        ↓  
+            ┌───────────┼───────────┐  
+            ↓           ↓           ↓  
+        Backend    Backend    Backend  
+        Container Container Container  
+            ↓           ↓           ↓  
+            └───────────┼───────────┘  
+                        ↓  
+                  PostgreSQL  
+                  (Persistent)  
+                        ↓  
+                   Redis Cache  
+                (Session, GA cache)
+
+### **Improvements**
+
+* Horizontal scaling (multiple backend containers)
+
+* Database persistence (PostgreSQL)
+
+* Session caching (Redis)
+
+* Load balancing
+
+* Monitoring & logging (Datadog, New Relic)
+
+* CDN for static files
+
+* API gateway
+
+---
+
+# **🎯 DEPLOYMENT STRATEGY**
+
+## **Development Environment**
+
+Local Machine  
+├─ Backend: localhost:8000 (uvicorn \--reload)  
+├─ Frontend: localhost:3000 (npm start)  
+├─ CORS: Localhost only  
+├─ Database: None (in-memory)  
+└─ Logging: Console
+
+## **Staging Environment**
+
+Staging Server (Railway/AWS)  
+├─ Backend: staging-api.aioptimize.com  
+├─ Frontend: staging.aioptimize.com  
+├─ CORS: Staging domain only  
+├─ Database: PostgreSQL (optional)  
+└─ Logging: Structured logging service
+
+## **Production Environment**
+
+Production Server (Railway/AWS/Google Cloud)  
+├─ Backend: api.aioptimize.com  
+├─ Frontend: app.aioptimize.com (Vercel CDN)  
+├─ CORS: Production domains only  
+├─ Database: PostgreSQL with backups  
+├─ Logging: Enterprise logging (Datadog)  
+├─ Monitoring: Performance monitoring  
+├─ Alerting: Email/Slack notifications  
+└─ Backup: Daily automated backups
+
+---
+
+# **📊 MONITORING & OBSERVABILITY**
+
+## **Metrics to Track (Current)**
+
+* API response times
+
+* Error rates by endpoint
+
+* Session count
+
+* Gemini API latency
+
+* File export success rate
+
+* User download counts
+
+## **Metrics to Track (Future)**
+
+* User engagement
+
+* Conversion funnel
+
+* Cost per session
+
+* GA optimization efficiency
+
+* User satisfaction (feedback)
+
+## **Logging Strategy**
+
+* Info level: Major operations
+
+* Warning level: Non-critical errors
+
+* Error level: Critical failures
+
+* Debug level: Development only
+
+---
+
+# **🔍 ERROR HANDLING & RESILIENCE**
+
+## **Error Categories & Handling**
+
+### **User Input Errors**
+
+* Invalid GeoJSON → User-friendly message
+
+* Missing file → Prompt to upload
+
+* Invalid coordinates → Suggest bounds
+
+### **API Errors**
+
+* Gemini API timeout → Use fallback chat
+
+* Rate limit exceeded → Queue message or inform user
+
+* Network error → Retry with exponential backoff
+
+### **System Errors**
+
+* Out of memory → Reject large file
+
+* File system full → Clean up old exports
+
+* Database connection → Use in-memory fallback
+
+### **Graceful Degradation**
+
+Gemini AI Available?  
+├─ YES → Use real AI  
+└─ NO → Use hardcoded responses (system still works)
+
+DXF Export Available?  
+├─ YES → Generate professional CAD  
+└─ NO → Return JSON alternative
+
+Database Available?  
+├─ YES → Persist to database  
+└─ NO → Use in-memory storage
+
+---
+
+# **✅ QUALITY ASSURANCE STRATEGY**
+
+## **Testing Levels**
+
+### **Unit Testing**
+
+* Test individual functions
+
+* Test geometry operations
+
+* Test GA fitness calculations
+
+* Test response generation logic
+
+### **Integration Testing**
+
+* Test API endpoints
+
+* Test frontend-backend communication
+
+* Test file upload flow
+
+* Test export generation
+
+### **End-to-End Testing**
+
+* Complete user workflows
+
+* Multi-step scenarios
+
+* Error recovery
+
+* Performance under load
+
+### **Performance Testing**
+
+* Load testing (concurrent users)
+
+* Stress testing (resource limits)
+
+* Latency testing (response times)
+
+* Scalability testing
+
+---
+
+# **📋 IMPLEMENTATION CHECKLIST**
+
+## **Phase 1: Level 2 Smart Demo (12 hours)**
+
+### **Frontend**
+
+* ☐ React \+ TypeScript setup
+
+* ☐ Component architecture designed
+
+* ☐ File upload UI implemented
+
+* ☐ 2D Konva canvas integrated
+
+* ☐ Layout options display created
+
+* ☐ Chat UI built
+
+* ☐ Styling finalized
+
+### **Backend**
+
+* ☐ FastAPI project initialized
+
+* ☐ Virtual environment created
+
+* ☐ Dependencies installed
+
+* ☐ API endpoints designed
+
+* ☐ GeoJSON parsing implemented
+
+* ☐ Genetic algorithm coded
+
+* ☐ Chat logic implemented
+
+* ☐ Error handling added
+
+### **Integration**
+
+* ☐ CORS enabled
+
+* ☐ Frontend connects to backend
+
+* ☐ File upload works end-to-end
+
+* ☐ Layout generation works
+
+* ☐ Chat responds
+
+* ☐ No console errors
+
+### **Testing**
+
+* ☐ Manual workflow testing
+
+* ☐ Error case testing
+
+* ☐ Performance verified
+
+* ☐ Browser compatibility checked
+
+---
+
+## **Phase 2: Level 2+ Enhancements (12 hours)**
+
+### **Gemini Integration**
+
+* ☐ API key obtained
+
+* ☐ google-generativeai library installed
+
+* ☐ GeminiService class created
+
+* ☐ Context building implemented
+
+* ☐ Fallback mechanism tested
+
+* ☐ Badge indicator added
+
+* ☐ Real responses verified
+
+### **DXF Export**
+
+* ☐ ezdxf library installed
+
+* ☐ DXFExportService class created
+
+* ☐ Layer setup implemented
+
+* ☐ Geometry drawing implemented
+
+* ☐ Title block added
+
+* ☐ Export endpoints created
+
+* ☐ UI buttons added
+
+* ☐ Download mechanism tested
+
+* ☐ ZIP creation implemented
+
+* ☐ File opening verified (CAD software)
+
+### **Final Testing**
+
+* ☐ Both features working
+
+* ☐ No console errors
+
+* ☐ No backend errors
+
+* ☐ Complete workflows tested
+
+* ☐ Performance acceptable
+
+* ☐ Documentation complete
+
+* ☐ Code committed to Git
+
+* ☐ Ready for production
+
+---
+
+# **🚀 DEPLOYMENT READINESS CHECKLIST**
+
+## **Pre-Deployment**
+
+* ☐ All tests passing
+
+* ☐ Code reviewed
+
+* ☐ Documentation complete
+
+* ☐ Security audit done
+
+* ☐ Performance baseline established
+
+* ☐ Backup strategy defined
+
+* ☐ Monitoring setup
+
+* ☐ Alert rules defined
+
+## **Deployment**
+
+* ☐ Frontend deployed (Vercel)
+
+* ☐ Backend deployed (Railway)
+
+* ☐ Environment variables set
+
+* ☐ API keys secured
+
+* ☐ CORS configured
+
+* ☐ HTTPS enforced
+
+* ☐ DNS configured
+
+## **Post-Deployment**
+
+* ☐ Smoke tests pass
+
+* ☐ Performance monitoring active
+
+* ☐ User feedback collected
+
+* ☐ Error tracking enabled
+
+* ☐ Incident response plan ready
+
+* ☐ Runbooks documented
+
+---
+
+**This architecture is battle-tested, production-ready, and designed for rapid iteration and scaling.**
+
+**Everything is documented, realistic, and achievable.**
+

docs/MVP-STATUS.md

@@ -0,0 +1,120 @@
+# AIOptimize™ MVP - Final Status Report
+
+## Tổng quan hoàn thành
+
+| Component | Status | Details |
+|-----------|--------|---------|
+| **Backend API** | ✅ 100% | 10 endpoints |
+| **Frontend UI** | ✅ 100% | React + Konva |
+| **DXF Input** | ✅ NEW | Parse LWPOLYLINE |
+| **DXF Output** | ✅ Fixed | Export layouts |
+| **Gemini AI** | ✅ Ready | API key configured |
+| **Zoom/Pan** | ✅ NEW | Mouse wheel + drag |
+
+---
+
+## Những gì đã tối ưu
+
+### Frontend
+1. **Map2DPlotter hoàn toàn mới**
+   - Zoom: mouse wheel + buttons
+   - Pan: kéo thả canvas
+   - Canvas size: 720x500px
+   - Transform coordinates chính xác
+
+2. **Layout tối ưu**
+   - Left panel: `max-width: 800px`
+   - Map section chiếm phần lớn
+   - Controls: zoom in/out/reset
+   
+3. **CSS**
+   - Map controls styling
+   - Zoom level indicator
+   - Grab cursor khi drag
+
+### Backend
+1. **Endpoint mới `/api/upload-dxf`**
+   - Parse file DXF
+   - Extract LWPOLYLINE/POLYLINE
+   - Tự động chọn polygon lớn nhất
+
+2. **Gemini API**
+   - API key từ `.env`
+   - Model: `gemini-2.0-flash-exp`
+   - Fallback responses nếu lỗi
+
+---
+
+## Files đã sửa
+
+| File | Changes |
+|------|---------|
+| `src/api/mvp_api.py` | +100 lines (upload-dxf) |
+| `frontend/src/components/Map2DPlotter.tsx` | Rewritten (zoom/pan) |
+| `frontend/src/App.tsx` | Map size 720x500 |
+| `frontend/src/App.css` | Map controls CSS |
+| `frontend/src/services/api.ts` | DXF routing |
+
+---
+
+## Build Status
+
+```
+Frontend:
+✓ 1818 modules transformed
+✓ built in 4.83s
+- index.js: 562KB (gzip: 178KB)
+- index.css: 9.5KB (gzip: 2.5KB)
+```
+
+---
+
+## Cách test
+
+```bash
+# Terminal 1 - Backend
+cd d:\Workspace\Project\REMB
+.\venv\Scripts\activate
+uvicorn src.api.mvp_api:app --reload --port 8000
+
+# Terminal 2 - Frontend
+cd frontend
+npm run dev
+```
+
+**Test DXF upload:**
+1. Tạo file DXF với LWPOLYLINE
+2. Upload qua UI
+3. Verify boundary hiển thị
+4. Generate layouts
+5. Export DXF
+
+---
+
+## API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/health` | Health check |
+| GET | `/api/sample-data` | Sample GeoJSON |
+| POST | `/api/upload-dxf` | **NEW** DXF input |
+| POST | `/api/upload-boundary-json` | JSON input |
+| POST | `/api/generate-layouts` | GA optimizer |
+| POST | `/api/chat` | Gemini AI |
+| POST | `/api/export-dxf` | Single DXF |
+| POST | `/api/export-all-dxf` | ZIP all layouts |
+
+---
+
+## Gemini API
+
+```
+Model: gemini-2.0-flash-exp
+Key: Configured in .env
+Status: Ready
+```
+
+Test chat với các câu hỏi:
+- "Which option is best?"
+- "Compare the layouts"
+- "How does the algorithm work?"

docs/Requirement.md

@@ -0,0 +1,8 @@
+Tóm tắt "Tech Stack" mã nguồn mở cho MVP khuyến nghị:
+
+Ngôn ngữ: Python 3.10+
+Tối ưu hóa (AI): Pymoo (NSGA-II) + Google OR-Tools (dùng solver HiGHS cho MILP).
+Xử lý hình học: GeoPandas + Shapely.
+Xuất bản vẽ: ezdxf.
+Backend/API: FastAPI.
+Database: PostgreSQL + PostGIS.

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```

frontend/eslint.config.js

@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>frontend</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "konva": "^10.0.12",
+    "lucide-react": "^0.555.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-konva": "^19.2.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.46.4",
+    "vite": "^7.2.4"
+  }
+}

frontend/src/App.css

@@ -0,0 +1,724 @@
+/**
+ * AIOptimize™ MVP - Styles
+ * Modern, premium design system
+ */
+
+/* === CSS Variables === */
+:root {
+  --primary: #6366f1;
+  --primary-dark: #4f46e5;
+  --primary-light: #818cf8;
+  --secondary: #10b981;
+  --accent: #f59e0b;
+  --danger: #ef4444;
+
+  --bg-dark: #0f172a;
+  --bg-card: #1e293b;
+  --bg-hover: #334155;
+  --bg-light: #f8fafc;
+
+  --text-primary: #f8fafc;
+  --text-secondary: #94a3b8;
+  --text-muted: #64748b;
+
+  --border: #334155;
+  --border-light: #475569;
+
+  --shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.3);
+  --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.4);
+
+  --radius: 12px;
+  --radius-sm: 8px;
+
+  --transition: all 0.2s ease;
+}
+
+/* === Base Styles === */
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  background: linear-gradient(135deg, var(--bg-dark) 0%, #1a1f35 100%);
+  color: var(--text-primary);
+  min-height: 100vh;
+  line-height: 1.5;
+}
+
+/* === Layout === */
+.app {
+  display: flex;
+  flex-direction: column;
+  min-height: 100vh;
+}
+
+.app-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 1rem 2rem;
+  background: rgba(15, 23, 42, 0.8);
+  backdrop-filter: blur(10px);
+  border-bottom: 1px solid var(--border);
+}
+
+.logo {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.logo svg {
+  color: var(--primary);
+}
+
+.logo h1 {
+  font-size: 1.5rem;
+  font-weight: 700;
+  background: linear-gradient(135deg, var(--primary-light), var(--secondary));
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+.tagline {
+  color: var(--text-secondary);
+  font-size: 0.875rem;
+}
+
+.app-main {
+  display: flex;
+  flex: 1;
+  padding: 1.5rem;
+  gap: 1.5rem;
+  max-width: 1600px;
+  margin: 0 auto;
+  width: 100%;
+}
+
+.left-panel {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  max-width: 800px;
+}
+
+.right-panel {
+  width: 400px;
+  flex-shrink: 0;
+}
+
+.app-footer {
+  padding: 1rem 2rem;
+  text-align: center;
+  color: var(--text-muted);
+  font-size: 0.75rem;
+  border-top: 1px solid var(--border);
+}
+
+/* === Buttons === */
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  padding: 0.75rem 1.25rem;
+  border-radius: var(--radius-sm);
+  font-weight: 600;
+  font-size: 0.875rem;
+  cursor: pointer;
+  border: none;
+  transition: var(--transition);
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.btn-primary {
+  background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+  color: white;
+}
+
+.btn-primary:hover:not(:disabled) {
+  transform: translateY(-1px);
+  box-shadow: var(--shadow-lg);
+}
+
+.btn-secondary {
+  background: var(--bg-card);
+  color: var(--text-primary);
+  border: 1px solid var(--border);
+}
+
+.btn-secondary:hover:not(:disabled) {
+  background: var(--bg-hover);
+}
+
+.btn-sm {
+  padding: 0.5rem 0.75rem;
+  font-size: 0.75rem;
+}
+
+.btn-export {
+  background: var(--secondary);
+  color: white;
+}
+
+.btn-export:hover:not(:disabled) {
+  background: #059669;
+}
+
+.btn-generate {
+  width: 100%;
+  padding: 1rem;
+  font-size: 1rem;
+}
+
+.btn-export-all {
+  width: 100%;
+}
+
+.btn-send {
+  padding: 0.75rem;
+  background: var(--primary);
+  color: white;
+  border-radius: var(--radius-sm);
+}
+
+.spin {
+  animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+  from {
+    transform: rotate(0deg);
+  }
+
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* === Upload Panel === */
+.upload-panel {
+  background: var(--bg-card);
+  border-radius: var(--radius);
+  padding: 1.5rem;
+  border: 1px solid var(--border);
+}
+
+.upload-header {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 1rem;
+}
+
+.upload-header svg {
+  color: var(--primary);
+}
+
+.upload-header h3 {
+  font-size: 1rem;
+  font-weight: 600;
+}
+
+.upload-buttons {
+  display: flex;
+  gap: 0.75rem;
+}
+
+.upload-status {
+  margin-top: 1rem;
+  padding: 0.5rem 0.75rem;
+  background: rgba(16, 185, 129, 0.1);
+  border-radius: var(--radius-sm);
+  color: var(--secondary);
+  font-size: 0.875rem;
+}
+
+/* === Generate Section === */
+.generate-section {
+  background: var(--bg-card);
+  border-radius: var(--radius);
+  padding: 1rem;
+  border: 1px solid var(--border);
+}
+
+/* === Map Container === */
+.map-section {
+  background: var(--bg-card);
+  border-radius: var(--radius);
+  padding: 1rem;
+  border: 1px solid var(--border);
+}
+
+.map-wrapper {
+  position: relative;
+}
+
+.map-controls {
+  position: absolute;
+  top: 10px;
+  right: 10px;
+  display: flex;
+  gap: 4px;
+  z-index: 10;
+  background: white;
+  padding: 4px;
+  border-radius: var(--radius-sm);
+  box-shadow: var(--shadow);
+}
+
+.map-controls button {
+  width: 32px;
+  height: 32px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: #f8fafc;
+  border: 1px solid #e2e8f0;
+  border-radius: 6px;
+  cursor: pointer;
+  color: #475569;
+  transition: var(--transition);
+}
+
+.map-controls button:hover {
+  background: #e2e8f0;
+  color: #1e293b;
+}
+
+.map-controls .zoom-level {
+  font-size: 11px;
+  color: #64748b;
+  padding: 0 8px;
+  display: flex;
+  align-items: center;
+}
+
+.map-hint {
+  position: absolute;
+  bottom: 8px;
+  left: 50%;
+  transform: translateX(-50%);
+  font-size: 11px;
+  color: #94a3b8;
+  background: rgba(255, 255, 255, 0.9);
+  padding: 4px 12px;
+  border-radius: 20px;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.map-container {
+  background: white;
+  border-radius: var(--radius-sm);
+  overflow: hidden;
+  cursor: grab;
+}
+
+.map-container:active {
+  cursor: grabbing;
+}
+
+/* === Options Panel === */
+.options-panel {
+  background: var(--bg-card);
+  border-radius: var(--radius);
+  padding: 1.5rem;
+  border: 1px solid var(--border);
+}
+
+.options-panel h3 {
+  font-size: 1rem;
+  font-weight: 600;
+  margin-bottom: 1rem;
+}
+
+.options-panel.empty {
+  text-align: center;
+  color: var(--text-muted);
+  padding: 2rem;
+}
+
+.options-grid {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.option-card {
+  background: var(--bg-dark);
+  border-radius: var(--radius-sm);
+  padding: 1rem;
+  border: 2px solid var(--border);
+  cursor: pointer;
+  transition: var(--transition);
+}
+
+.option-card:hover {
+  border-color: var(--border-light);
+  background: var(--bg-hover);
+}
+
+.option-card.selected {
+  border-color: var(--primary);
+  background: rgba(99, 102, 241, 0.1);
+}
+
+.option-header {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 0.5rem;
+}
+
+.option-icon {
+  font-size: 1.5rem;
+}
+
+.option-header h4 {
+  flex: 1;
+  font-size: 1rem;
+  font-weight: 600;
+}
+
+.selected-check {
+  color: var(--primary);
+}
+
+.option-description {
+  color: var(--text-secondary);
+  font-size: 0.75rem;
+  margin-bottom: 1rem;
+}
+
+.option-metrics {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 0.75rem;
+  margin-bottom: 1rem;
+}
+
+.metric {
+  text-align: center;
+}
+
+.metric-label {
+  display: block;
+  font-size: 0.625rem;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  margin-bottom: 0.25rem;
+}
+
+.metric-value {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.metric-value.fitness {
+  color: var(--secondary);
+}
+
+.option-footer {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.compliance {
+  font-size: 0.75rem;
+  padding: 0.25rem 0.5rem;
+  border-radius: 4px;
+}
+
+.compliance.pass {
+  background: rgba(16, 185, 129, 0.1);
+  color: var(--secondary);
+}
+
+.compliance.fail {
+  background: rgba(239, 68, 68, 0.1);
+  color: var(--danger);
+}
+
+/* === Export Panel === */
+.export-panel {
+  background: var(--bg-card);
+  border-radius: var(--radius);
+  padding: 1rem;
+  border: 1px solid var(--border);
+}
+
+/* === Chat Interface === */
+.chat-interface {
+  background: var(--bg-card);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  height: calc(100vh - 180px);
+  max-height: 700px;
+}
+
+.chat-header {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 1rem 1.25rem;
+  border-bottom: 1px solid var(--border);
+}
+
+.chat-header svg {
+  color: var(--primary);
+}
+
+.chat-header .sparkle {
+  color: var(--accent);
+}
+
+.chat-header h3 {
+  flex: 1;
+  font-size: 1rem;
+  font-weight: 600;
+}
+
+.chat-messages {
+  flex: 1;
+  overflow-y: auto;
+  padding: 1rem;
+}
+
+.chat-welcome {
+  text-align: center;
+  padding: 2rem 1rem;
+  color: var(--text-secondary);
+}
+
+.welcome-icon {
+  color: var(--primary);
+  margin-bottom: 1rem;
+}
+
+.chat-welcome h4 {
+  font-size: 1.125rem;
+  color: var(--text-primary);
+  margin-bottom: 0.5rem;
+}
+
+.chat-welcome p {
+  font-size: 0.875rem;
+  margin-bottom: 1.5rem;
+}
+
+.suggested-questions {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.suggested-btn {
+  background: var(--bg-dark);
+  border: 1px solid var(--border);
+  color: var(--text-secondary);
+  padding: 0.75rem 1rem;
+  border-radius: var(--radius-sm);
+  font-size: 0.75rem;
+  cursor: pointer;
+  text-align: left;
+  transition: var(--transition);
+}
+
+.suggested-btn:hover:not(:disabled) {
+  background: var(--bg-hover);
+  color: var(--text-primary);
+  border-color: var(--primary);
+}
+
+.message {
+  display: flex;
+  gap: 0.75rem;
+  margin-bottom: 1rem;
+}
+
+.message-icon {
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+
+.message.user .message-icon {
+  background: var(--primary);
+  color: white;
+}
+
+.message.assistant .message-icon {
+  background: var(--secondary);
+  color: white;
+}
+
+.message-content {
+  flex: 1;
+  background: var(--bg-dark);
+  padding: 0.75rem 1rem;
+  border-radius: var(--radius-sm);
+  font-size: 0.875rem;
+}
+
+.message.user .message-content {
+  background: rgba(99, 102, 241, 0.1);
+}
+
+.message-text {
+  white-space: pre-wrap;
+  line-height: 1.6;
+}
+
+.model-badge {
+  margin-top: 0.5rem;
+  font-size: 0.625rem;
+  color: var(--text-muted);
+}
+
+.model-badge.gemini {
+  color: var(--secondary);
+}
+
+.typing-indicator {
+  display: flex;
+  gap: 4px;
+}
+
+.typing-indicator span {
+  width: 6px;
+  height: 6px;
+  background: var(--text-muted);
+  border-radius: 50%;
+  animation: bounce 1.4s infinite ease-in-out;
+}
+
+.typing-indicator span:nth-child(2) {
+  animation-delay: 0.2s;
+}
+
+.typing-indicator span:nth-child(3) {
+  animation-delay: 0.4s;
+}
+
+@keyframes bounce {
+
+  0%,
+  80%,
+  100% {
+    transform: translateY(0);
+  }
+
+  40% {
+    transform: translateY(-6px);
+  }
+}
+
+.chat-input-form {
+  display: flex;
+  gap: 0.75rem;
+  padding: 1rem;
+  border-top: 1px solid var(--border);
+}
+
+.chat-input {
+  flex: 1;
+  background: var(--bg-dark);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  padding: 0.75rem 1rem;
+  color: var(--text-primary);
+  font-size: 0.875rem;
+}
+
+.chat-input:focus {
+  outline: none;
+  border-color: var(--primary);
+}
+
+.chat-input:disabled {
+  opacity: 0.5;
+}
+
+/* === Error Banner === */
+.error-banner {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.75rem 1.5rem;
+  background: rgba(239, 68, 68, 0.1);
+  border-bottom: 1px solid var(--danger);
+  color: var(--danger);
+}
+
+.error-banner svg {
+  flex-shrink: 0;
+}
+
+.error-banner span {
+  flex: 1;
+  font-size: 0.875rem;
+}
+
+.error-banner button {
+  background: none;
+  border: none;
+  color: var(--danger);
+  font-size: 1.25rem;
+  cursor: pointer;
+  padding: 0 0.5rem;
+}
+
+/* === Responsive === */
+@media (max-width: 1200px) {
+  .app-main {
+    flex-direction: column;
+  }
+
+  .left-panel {
+    max-width: 100%;
+  }
+
+  .right-panel {
+    width: 100%;
+  }
+
+  .chat-interface {
+    height: 400px;
+  }
+}
+
+@media (max-width: 768px) {
+  .app-header {
+    flex-direction: column;
+    gap: 0.5rem;
+    text-align: center;
+  }
+
+  .upload-buttons {
+    flex-direction: column;
+  }
+
+  .option-metrics {
+    grid-template-columns: repeat(2, 1fr);
+  }
+}

frontend/src/App.tsx

@@ -0,0 +1,333 @@
+/**
+ * AIOptimize™ MVP - Main Application
+ * Industrial Estate Planning Optimization
+ */
+import { useState, useCallback, useEffect } from 'react';
+import { Layers, Zap, AlertCircle, Loader2 } from 'lucide-react';
+import { FileUploadPanel } from './components/FileUploadPanel';
+import { Map2DPlotter } from './components/Map2DPlotter';
+import { LayoutOptionsPanel } from './components/LayoutOptionsPanel';
+import { ChatInterface } from './components/ChatInterface';
+import { ExportPanel } from './components/ExportPanel';
+import { apiService } from './services/api';
+import type { AppState, ChatMessage, GeoJSONFeature } from './types';
+import './App.css';
+
+function App() {
+  // Application state
+  const [state, setState] = useState<AppState>({
+    sessionId: null,
+    boundary: null,
+    boundaryCoords: null,
+    metadata: null,
+    options: [],
+    selectedOption: null,
+    messages: [],
+    loading: false,
+    error: null,
+  });
+
+  // Loading states
+  const [uploadLoading, setUploadLoading] = useState(false);
+  const [generateLoading, setGenerateLoading] = useState(false);
+  const [chatLoading, setChatLoading] = useState(false);
+  const [exportLoading, setExportLoading] = useState(false);
+
+  // Debug: monitor options changes
+  useEffect(() => {
+    console.log('State options changed:', state.options.length, state.options);
+  }, [state.options]);
+
+  // Extract boundary coords from GeoJSON
+  const extractCoords = (geojson: GeoJSONFeature): number[][] => {
+    if (geojson.type === 'Feature' && geojson.geometry) {
+      return geojson.geometry.coordinates[0];
+    }
+    return [];
+  };
+
+  // Handle file upload
+  const handleUpload = useCallback(async (file: File) => {
+    setUploadLoading(true);
+    setState(prev => ({ ...prev, error: null }));
+
+    try {
+      const response = await apiService.uploadBoundaryFile(file);
+      const coords = extractCoords(response.boundary);
+
+      setState(prev => ({
+        ...prev,
+        sessionId: response.session_id,
+        boundary: response.boundary,
+        boundaryCoords: coords,
+        metadata: response.metadata,
+        options: [],
+        selectedOption: null,
+      }));
+    } catch (err) {
+      setState(prev => ({
+        ...prev,
+        error: err instanceof Error ? err.message : 'Upload failed'
+      }));
+    } finally {
+      setUploadLoading(false);
+    }
+  }, []);
+
+  // Handle sample data
+  const handleSampleData = useCallback(async () => {
+    setUploadLoading(true);
+    setState(prev => ({ ...prev, error: null }));
+
+    try {
+      const sampleData = await apiService.getSampleData();
+      const response = await apiService.uploadBoundary(sampleData);
+      const coords = extractCoords(response.boundary);
+
+      setState(prev => ({
+        ...prev,
+        sessionId: response.session_id,
+        boundary: response.boundary,
+        boundaryCoords: coords,
+        metadata: response.metadata,
+        options: [],
+        selectedOption: null,
+      }));
+    } catch (err) {
+      setState(prev => ({
+        ...prev,
+        error: err instanceof Error ? err.message : 'Failed to load sample data'
+      }));
+    } finally {
+      setUploadLoading(false);
+    }
+  }, []);
+
+  // Generate layouts
+  const handleGenerate = useCallback(async () => {
+    if (!state.sessionId) return;
+
+    setGenerateLoading(true);
+    setState(prev => ({ ...prev, error: null }));
+
+    try {
+      const response = await apiService.generateLayouts(state.sessionId);
+      console.log('Generate response:', response);
+
+      if (response.options && response.options.length > 0) {
+        setState(prev => ({
+          ...prev,
+          options: response.options,
+          selectedOption: response.options[0]?.id || null,
+        }));
+      } else {
+        setState(prev => ({
+          ...prev,
+          error: 'No layout options returned'
+        }));
+      }
+    } catch (err) {
+      console.error('Generate error:', err);
+      setState(prev => ({
+        ...prev,
+        error: err instanceof Error ? err.message : 'Generation failed'
+      }));
+    } finally {
+      setGenerateLoading(false);
+    }
+  }, [state.sessionId]);
+
+  // Select layout option
+  const handleSelectOption = useCallback((optionId: number) => {
+    setState(prev => ({ ...prev, selectedOption: optionId }));
+  }, []);
+
+  // Export single DXF
+  const handleExportDxf = useCallback(async (optionId: number) => {
+    if (!state.sessionId) return;
+
+    setExportLoading(true);
+
+    try {
+      const blob = await apiService.exportDxf(state.sessionId, optionId);
+
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `layout_option_${optionId}.dxf`;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      window.URL.revokeObjectURL(url);
+    } catch (err) {
+      setState(prev => ({
+        ...prev,
+        error: err instanceof Error ? err.message : 'Export failed'
+      }));
+    } finally {
+      setExportLoading(false);
+    }
+  }, [state.sessionId]);
+
+  // Export all as ZIP
+  const handleExportAll = useCallback(async () => {
+    if (!state.sessionId) return;
+
+    setExportLoading(true);
+
+    try {
+      const blob = await apiService.exportAllDxf(state.sessionId);
+
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = 'all_layouts.zip';
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      window.URL.revokeObjectURL(url);
+    } catch (err) {
+      setState(prev => ({
+        ...prev,
+        error: err instanceof Error ? err.message : 'Export failed'
+      }));
+    } finally {
+      setExportLoading(false);
+    }
+  }, [state.sessionId]);
+
+  // Send chat message
+  const handleChat = useCallback(async (message: string) => {
+    if (!state.sessionId) return;
+
+    const userMessage: ChatMessage = { role: 'user', content: message };
+    setState(prev => ({
+      ...prev,
+      messages: [...prev.messages, userMessage],
+    }));
+
+    setChatLoading(true);
+
+    try {
+      const response = await apiService.chat(state.sessionId, message);
+
+      const assistantMessage: ChatMessage = {
+        role: 'assistant',
+        content: response.message,
+        model: response.model,
+      };
+
+      setState(prev => ({
+        ...prev,
+        messages: [...prev.messages, assistantMessage],
+      }));
+    } catch (err) {
+      const errorMessage: ChatMessage = {
+        role: 'assistant',
+        content: 'Sorry, I encountered an error. Please try again.',
+        model: 'fallback',
+      };
+      setState(prev => ({
+        ...prev,
+        messages: [...prev.messages, errorMessage],
+      }));
+    } finally {
+      setChatLoading(false);
+    }
+  }, [state.sessionId]);
+
+  // Get selected option object
+  const selectedOptionData = state.options.find(o => o.id === state.selectedOption) || null;
+
+  return (
+    <div className="app">
+      <header className="app-header">
+        <div className="logo">
+          <Layers size={28} />
+          <h1>AIOptimize™</h1>
+        </div>
+        <p className="tagline">AI-Powered Industrial Estate Planning</p>
+      </header>
+
+      {state.error && (
+        <div className="error-banner">
+          <AlertCircle size={18} />
+          <span>{state.error}</span>
+          <button onClick={() => setState(prev => ({ ...prev, error: null }))}>×</button>
+        </div>
+      )}
+
+      <main className="app-main">
+        <div className="left-panel">
+          <FileUploadPanel
+            onUpload={handleUpload}
+            onSampleData={handleSampleData}
+            loading={uploadLoading}
+            hasData={!!state.boundary}
+          />
+
+          {state.boundary && (
+            <div className="generate-section">
+              <button
+                className="btn btn-primary btn-generate"
+                onClick={handleGenerate}
+                disabled={generateLoading}
+              >
+                {generateLoading ? (
+                  <>
+                    <Loader2 size={18} className="spin" />
+                    Optimizing...
+                  </>
+                ) : (
+                  <>
+                    <Zap size={18} />
+                    Generate Layouts
+                  </>
+                )}
+              </button>
+            </div>
+          )}
+
+          <div className="map-section">
+            <Map2DPlotter
+              boundaryCoords={state.boundaryCoords}
+              metadata={state.metadata}
+              selectedOption={selectedOptionData}
+              width={720}
+              height={500}
+            />
+          </div>
+
+          <LayoutOptionsPanel
+            options={state.options}
+            selectedOptionId={state.selectedOption}
+            onSelect={handleSelectOption}
+            onExport={handleExportDxf}
+            loading={exportLoading}
+          />
+
+          <ExportPanel
+            hasLayouts={state.options.length > 0}
+            onExportAll={handleExportAll}
+            loading={exportLoading}
+          />
+        </div>
+
+        <div className="right-panel">
+          <ChatInterface
+            messages={state.messages}
+            onSendMessage={handleChat}
+            loading={chatLoading}
+            disabled={!state.sessionId}
+          />
+        </div>
+      </main>
+
+      <footer className="app-footer">
+        <p>AIOptimize™ MVP • Built with React + FastAPI + Genetic Algorithm</p>
+      </footer>
+    </div>
+  );
+}
+
+export default App;

frontend/src/components/ChatInterface.tsx

@@ -0,0 +1,127 @@
+// ChatInterface Component - AI Chat for layout questions
+import React, { useState, useRef, useEffect } from 'react';
+import { Send, Bot, User, Sparkles } from 'lucide-react';
+import type { ChatMessage } from '../types';
+
+interface ChatInterfaceProps {
+    messages: ChatMessage[];
+    onSendMessage: (message: string) => void;
+    loading: boolean;
+    disabled: boolean;
+}
+
+export const ChatInterface: React.FC<ChatInterfaceProps> = ({
+    messages,
+    onSendMessage,
+    loading,
+    disabled,
+}) => {
+    const [input, setInput] = useState('');
+    const messagesEndRef = useRef<HTMLDivElement>(null);
+
+    // Auto-scroll to bottom on new messages
+    useEffect(() => {
+        messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+    }, [messages]);
+
+    const handleSubmit = (e: React.FormEvent) => {
+        e.preventDefault();
+        if (input.trim() && !loading && !disabled) {
+            onSendMessage(input.trim());
+            setInput('');
+        }
+    };
+
+    const suggestedQuestions = [
+        "What's the difference between the options?",
+        "Which layout do you recommend?",
+        "How does the optimization work?",
+        "What are the compliance requirements?",
+    ];
+
+    return (
+        <div className="chat-interface">
+            <div className="chat-header">
+                <Bot size={20} />
+                <h3>AI Assistant</h3>
+                <Sparkles size={16} className="sparkle" />
+            </div>
+
+            <div className="chat-messages">
+                {messages.length === 0 ? (
+                    <div className="chat-welcome">
+                        <Bot size={40} className="welcome-icon" />
+                        <h4>Ask about your layouts</h4>
+                        <p>I can help you understand optimization options, metrics, and compliance.</p>
+
+                        <div className="suggested-questions">
+                            {suggestedQuestions.map((q, i) => (
+                                <button
+                                    key={i}
+                                    className="suggested-btn"
+                                    onClick={() => onSendMessage(q)}
+                                    disabled={disabled || loading}
+                                >
+                                    {q}
+                                </button>
+                            ))}
+                        </div>
+                    </div>
+                ) : (
+                    messages.map((msg, index) => (
+                        <div key={index} className={`message ${msg.role}`}>
+                            <div className="message-icon">
+                                {msg.role === 'user' ? <User size={16} /> : <Bot size={16} />}
+                            </div>
+                            <div className="message-content">
+                                <div className="message-text">{msg.content}</div>
+                                {msg.role === 'assistant' && msg.model && (
+                                    <div className={`model-badge ${msg.model === 'gemini-2.0-flash' ? 'gemini' : 'fallback'}`}>
+                                        {msg.model === 'gemini-2.0-flash' ? '🤖 Powered by Gemini' : '💬 Fallback Mode'}
+                                    </div>
+                                )}
+                            </div>
+                        </div>
+                    ))
+                )}
+
+                {loading && (
+                    <div className="message assistant loading">
+                        <div className="message-icon">
+                            <Bot size={16} />
+                        </div>
+                        <div className="message-content">
+                            <div className="typing-indicator">
+                                <span></span>
+                                <span></span>
+                                <span></span>
+                            </div>
+                        </div>
+                    </div>
+                )}
+
+                <div ref={messagesEndRef} />
+            </div>
+
+            <form className="chat-input-form" onSubmit={handleSubmit}>
+                <input
+                    type="text"
+                    value={input}
+                    onChange={(e) => setInput(e.target.value)}
+                    placeholder={disabled ? "Upload a site first..." : "Ask about your layouts..."}
+                    disabled={loading || disabled}
+                    className="chat-input"
+                />
+                <button
+                    type="submit"
+                    disabled={!input.trim() || loading || disabled}
+                    className="btn btn-send"
+                >
+                    <Send size={18} />
+                </button>
+            </form>
+        </div>
+    );
+};
+
+export default ChatInterface;

frontend/src/components/ExportPanel.tsx

@@ -0,0 +1,35 @@
+// ExportPanel Component - Export buttons for DXF download
+import React from 'react';
+import { Download, Package } from 'lucide-react';
+
+interface ExportPanelProps {
+    hasLayouts: boolean;
+    onExportAll: () => void;
+    loading: boolean;
+}
+
+export const ExportPanel: React.FC<ExportPanelProps> = ({
+    hasLayouts,
+    onExportAll,
+    loading,
+}) => {
+    if (!hasLayouts) {
+        return null;
+    }
+
+    return (
+        <div className="export-panel">
+            <button
+                className="btn btn-primary btn-export-all"
+                onClick={onExportAll}
+                disabled={loading}
+            >
+                <Package size={18} />
+                Export All as ZIP
+                <Download size={16} />
+            </button>
+        </div>
+    );
+};
+
+export default ExportPanel;

frontend/src/components/FileUploadPanel.tsx

@@ -0,0 +1,75 @@
+// FileUploadPanel Component
+import React, { useRef } from 'react';
+import { Upload, FileJson, Zap } from 'lucide-react';
+
+interface FileUploadPanelProps {
+    onUpload: (file: File) => void;
+    onSampleData: () => void;
+    loading: boolean;
+    hasData: boolean;
+}
+
+export const FileUploadPanel: React.FC<FileUploadPanelProps> = ({
+    onUpload,
+    onSampleData,
+    loading,
+    hasData,
+}) => {
+    const fileInputRef = useRef<HTMLInputElement>(null);
+
+    const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+        const file = e.target.files?.[0];
+        if (file) {
+            onUpload(file);
+        }
+    };
+
+    const handleClick = () => {
+        fileInputRef.current?.click();
+    };
+
+    return (
+        <div className="upload-panel">
+            <div className="upload-header">
+                <FileJson size={24} />
+                <h3>Site Boundary</h3>
+            </div>
+
+            <div className="upload-buttons">
+                <button
+                    className="btn btn-primary"
+                    onClick={handleClick}
+                    disabled={loading}
+                >
+                    <Upload size={18} />
+                    {hasData ? 'Replace Boundary' : 'Upload DXF / GeoJSON'}
+                </button>
+
+                <button
+                    className="btn btn-secondary"
+                    onClick={onSampleData}
+                    disabled={loading}
+                >
+                    <Zap size={18} />
+                    Use Sample Data
+                </button>
+            </div>
+
+            <input
+                ref={fileInputRef}
+                type="file"
+                accept=".dxf,.geojson,.json"
+                onChange={handleFileChange}
+                style={{ display: 'none' }}
+            />
+
+            {hasData && (
+                <div className="upload-status">
+                    ✅ Boundary loaded
+                </div>
+            )}
+        </div>
+    );
+};
+
+export default FileUploadPanel;

frontend/src/components/LayoutOptionsPanel.tsx

@@ -0,0 +1,91 @@
+// LayoutOptionsPanel - Display 3 layout options with metrics
+import React from 'react';
+import { Download, Check } from 'lucide-react';
+import type { LayoutOption } from '../types';
+
+interface LayoutOptionsPanelProps {
+    options: LayoutOption[];
+    selectedOptionId: number | null;
+    onSelect: (optionId: number) => void;
+    onExport: (optionId: number) => void;
+    loading: boolean;
+}
+
+export const LayoutOptionsPanel: React.FC<LayoutOptionsPanelProps> = ({
+    options,
+    selectedOptionId,
+    onSelect,
+    onExport,
+    loading,
+}) => {
+    if (options.length === 0) {
+        return (
+            <div className="options-panel empty">
+                <p>Generate layouts to see optimization options</p>
+            </div>
+        );
+    }
+
+    return (
+        <div className="options-panel">
+            <h3>Layout Options</h3>
+            <div className="options-grid">
+                {options.map((option) => (
+                    <div
+                        key={option.id}
+                        className={`option-card ${selectedOptionId === option.id ? 'selected' : ''}`}
+                        onClick={() => onSelect(option.id)}
+                    >
+                        <div className="option-header">
+                            <span className="option-icon">{option.icon}</span>
+                            <h4>{option.name}</h4>
+                            {selectedOptionId === option.id && (
+                                <Check size={18} className="selected-check" />
+                            )}
+                        </div>
+
+                        <p className="option-description">{option.description}</p>
+
+                        <div className="option-metrics">
+                            <div className="metric">
+                                <span className="metric-label">Plots</span>
+                                <span className="metric-value">{option.metrics.total_plots}</span>
+                            </div>
+                            <div className="metric">
+                                <span className="metric-label">Total Area</span>
+                                <span className="metric-value">{option.metrics.total_area.toLocaleString()} m²</span>
+                            </div>
+                            <div className="metric">
+                                <span className="metric-label">Avg Size</span>
+                                <span className="metric-value">{Math.round(option.metrics.avg_size).toLocaleString()} m²</span>
+                            </div>
+                            <div className="metric">
+                                <span className="metric-label">Fitness</span>
+                                <span className="metric-value fitness">{(option.metrics.fitness * 100).toFixed(0)}%</span>
+                            </div>
+                        </div>
+
+                        <div className="option-footer">
+                            <span className={`compliance ${option.metrics.compliance === 'PASS' ? 'pass' : 'fail'}`}>
+                                {option.metrics.compliance === 'PASS' ? '✓ Compliant' : '✗ Issues'}
+                            </span>
+                            <button
+                                className="btn btn-sm btn-export"
+                                onClick={(e) => {
+                                    e.stopPropagation();
+                                    onExport(option.id);
+                                }}
+                                disabled={loading}
+                            >
+                                <Download size={14} />
+                                DXF
+                            </button>
+                        </div>
+                    </div>
+                ))}
+            </div>
+        </div>
+    );
+};
+
+export default LayoutOptionsPanel;

frontend/src/components/Map2DPlotter.tsx

@@ -0,0 +1,274 @@
+// Map2DPlotter Component - Konva.js canvas with zoom/pan for site visualization
+import React, { useMemo, useState, useRef, useCallback } from 'react';
+import { Stage, Layer, Line, Rect, Text, Group } from 'react-konva';
+import { ZoomIn, ZoomOut, Move, Maximize2 } from 'lucide-react';
+import type { LayoutOption, SiteMetadata } from '../types';
+import type Konva from 'konva';
+
+interface Map2DPlotterProps {
+    boundaryCoords: number[][] | null;
+    metadata: SiteMetadata | null;
+    selectedOption: LayoutOption | null;
+    width?: number;
+    height?: number;
+}
+
+export const Map2DPlotter: React.FC<Map2DPlotterProps> = ({
+    boundaryCoords,
+    metadata,
+    selectedOption,
+    width = 800,
+    height = 600,
+}) => {
+    // Zoom and pan state
+    const [scale, setScale] = useState(1);
+    const [position, setPosition] = useState({ x: 0, y: 0 });
+    const stageRef = useRef<Konva.Stage>(null);
+
+    // Calculate base transform to fit boundary in canvas
+    const baseTransform = useMemo(() => {
+        if (!boundaryCoords || boundaryCoords.length === 0) {
+            return { scale: 1, offsetX: 0, offsetY: 0, minX: 0, minY: 0 };
+        }
+
+        const xs = boundaryCoords.map(c => c[0]);
+        const ys = boundaryCoords.map(c => c[1]);
+
+        const minX = Math.min(...xs);
+        const maxX = Math.max(...xs);
+        const minY = Math.min(...ys);
+        const maxY = Math.max(...ys);
+
+        const dataWidth = maxX - minX;
+        const dataHeight = maxY - minY;
+
+        const padding = 60;
+        const scaleX = (width - padding * 2) / dataWidth;
+        const scaleY = (height - padding * 2) / dataHeight;
+        const baseScale = Math.min(scaleX, scaleY) * 0.85;
+
+        const offsetX = padding + (width - padding * 2 - dataWidth * baseScale) / 2 - minX * baseScale;
+        const offsetY = padding + (height - padding * 2 - dataHeight * baseScale) / 2 + maxY * baseScale;
+
+        return { scale: baseScale, offsetX, offsetY, minX, minY, maxY };
+    }, [boundaryCoords, width, height]);
+
+    // Transform coordinates (flip Y for screen coords)
+    const transformPoint = useCallback((x: number, y: number): [number, number] => {
+        return [
+            x * baseTransform.scale + baseTransform.offsetX,
+            baseTransform.offsetY - y * baseTransform.scale,
+        ];
+    }, [baseTransform]);
+
+    // Flatten boundary coords for Konva Line
+    const boundaryPoints = useMemo(() => {
+        if (!boundaryCoords) return [];
+        return boundaryCoords.flatMap(([x, y]) => transformPoint(x, y));
+    }, [boundaryCoords, transformPoint]);
+
+    // Calculate setback boundary (50m inside)
+    const setbackPoints = useMemo(() => {
+        if (!boundaryCoords || boundaryCoords.length < 3) return [];
+
+        const xs = boundaryCoords.map(c => c[0]);
+        const ys = boundaryCoords.map(c => c[1]);
+        const centerX = xs.reduce((a, b) => a + b, 0) / xs.length;
+        const centerY = ys.reduce((a, b) => a + b, 0) / ys.length;
+
+        const shrinkFactor = 0.82;
+        const shrunkCoords = boundaryCoords.map(([x, y]) => [
+            centerX + (x - centerX) * shrinkFactor,
+            centerY + (y - centerY) * shrinkFactor,
+        ]);
+
+        return shrunkCoords.flatMap(([x, y]) => transformPoint(x, y));
+    }, [boundaryCoords, transformPoint]);
+
+    // Handle zoom
+    const handleZoom = (delta: number) => {
+        const newScale = Math.min(Math.max(scale + delta, 0.5), 3);
+        setScale(newScale);
+    };
+
+    // Handle wheel zoom
+    const handleWheel = (e: Konva.KonvaEventObject<WheelEvent>) => {
+        e.evt.preventDefault();
+        const delta = e.evt.deltaY > 0 ? -0.1 : 0.1;
+        handleZoom(delta);
+    };
+
+    // Reset view
+    const resetView = () => {
+        setScale(1);
+        setPosition({ x: 0, y: 0 });
+    };
+
+    // Render plots from selected option
+    const renderPlots = () => {
+        if (!selectedOption?.plots) return null;
+
+        return selectedOption.plots.map((plot, index) => {
+            // Transform plot position
+            const [x, y] = transformPoint(plot.x, plot.y + plot.height);
+            const w = plot.width * baseTransform.scale;
+            const h = plot.height * baseTransform.scale;
+
+            // Color based on index
+            const colors = ['#3B82F6', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6'];
+            const color = colors[index % colors.length];
+
+            return (
+                <Group key={index}>
+                    <Rect
+                        x={x}
+                        y={y}
+                        width={w}
+                        height={h}
+                        fill={`${color}33`}
+                        stroke={color}
+                        strokeWidth={2}
+                        cornerRadius={2}
+                    />
+                    <Text
+                        x={x + w / 2 - 12}
+                        y={y + h / 2 - 10}
+                        text={`P${index + 1}`}
+                        fontSize={14}
+                        fill={color}
+                        fontStyle="bold"
+                    />
+                    <Text
+                        x={x + w / 2 - 25}
+                        y={y + h / 2 + 6}
+                        text={`${Math.round(plot.area)}m²`}
+                        fontSize={10}
+                        fill="#666"
+                    />
+                </Group>
+            );
+        });
+    };
+
+    return (
+        <div className="map-wrapper">
+            {/* Zoom controls */}
+            <div className="map-controls">
+                <button onClick={() => handleZoom(0.2)} title="Zoom In">
+                    <ZoomIn size={16} />
+                </button>
+                <button onClick={() => handleZoom(-0.2)} title="Zoom Out">
+                    <ZoomOut size={16} />
+                </button>
+                <button onClick={resetView} title="Reset View">
+                    <Maximize2 size={16} />
+                </button>
+                <span className="zoom-level">{Math.round(scale * 100)}%</span>
+            </div>
+
+            <div className="map-container">
+                <Stage
+                    ref={stageRef}
+                    width={width}
+                    height={height}
+                    scaleX={scale}
+                    scaleY={scale}
+                    x={position.x}
+                    y={position.y}
+                    draggable
+                    onWheel={handleWheel}
+                    onDragEnd={(e) => setPosition({ x: e.target.x(), y: e.target.y() })}
+                >
+                    <Layer>
+                        {/* Background grid */}
+                        {[...Array(25)].map((_, i) => (
+                            <Line
+                                key={`grid-h-${i}`}
+                                points={[0, i * (height / 25), width, i * (height / 25)]}
+                                stroke="#f0f0f0"
+                                strokeWidth={1}
+                            />
+                        ))}
+                        {[...Array(25)].map((_, i) => (
+                            <Line
+                                key={`grid-v-${i}`}
+                                points={[i * (width / 25), 0, i * (width / 25), height]}
+                                stroke="#f0f0f0"
+                                strokeWidth={1}
+                            />
+                        ))}
+
+                        {/* Site boundary */}
+                        {boundaryPoints.length > 0 && (
+                            <Line
+                                points={boundaryPoints}
+                                closed
+                                stroke="#1e293b"
+                                strokeWidth={3}
+                                fill="rgba(226, 232, 240, 0.3)"
+                            />
+                        )}
+
+                        {/* Setback zone */}
+                        {setbackPoints.length > 0 && (
+                            <Line
+                                points={setbackPoints}
+                                closed
+                                stroke="#ef4444"
+                                strokeWidth={2}
+                                dash={[10, 5]}
+                                fill="rgba(239, 68, 68, 0.05)"
+                            />
+                        )}
+
+                        {/* Plots */}
+                        {renderPlots()}
+
+                        {/* Legend */}
+                        <Group x={10} y={10}>
+                            <Rect x={0} y={0} width={170} height={90} fill="white" opacity={0.95} cornerRadius={8} shadowBlur={5} shadowColor="rgba(0,0,0,0.1)" />
+                            <Text x={10} y={8} text="Legend" fontSize={12} fontStyle="bold" fill="#333" />
+                            <Line points={[10, 30, 35, 30]} stroke="#1e293b" strokeWidth={3} />
+                            <Text x={45} y={24} text="Site Boundary" fontSize={11} fill="#666" />
+                            <Line points={[10, 50, 35, 50]} stroke="#ef4444" strokeWidth={2} dash={[5, 3]} />
+                            <Text x={45} y={44} text="Setback (50m)" fontSize={11} fill="#666" />
+                            <Rect x={10} y={62} width={25} height={18} fill="rgba(59, 130, 246, 0.2)" stroke="#3B82F6" strokeWidth={2} />
+                            <Text x={45} y={66} text="Industrial Plots" fontSize={11} fill="#666" />
+                        </Group>
+
+                        {/* Metadata */}
+                        {metadata && (
+                            <Group x={width - 160} y={10}>
+                                <Rect x={0} y={0} width={150} height={60} fill="white" opacity={0.95} cornerRadius={8} shadowBlur={5} shadowColor="rgba(0,0,0,0.1)" />
+                                <Text x={10} y={8} text="Site Info" fontSize={12} fontStyle="bold" fill="#333" />
+                                <Text x={10} y={26} text={`Area: ${(metadata.area / 10000).toFixed(2)} ha`} fontSize={11} fill="#666" />
+                                <Text x={10} y={42} text={`Perimeter: ${metadata.perimeter.toFixed(0)} m`} fontSize={11} fill="#666" />
+                            </Group>
+                        )}
+
+                        {/* Empty state */}
+                        {!boundaryCoords && (
+                            <Group>
+                                <Rect x={width / 2 - 120} y={height / 2 - 30} width={240} height={60} fill="#f8fafc" cornerRadius={8} />
+                                <Text
+                                    x={width / 2 - 100}
+                                    y={height / 2 - 10}
+                                    text="Upload DXF or GeoJSON to start"
+                                    fontSize={14}
+                                    fill="#94a3b8"
+                                />
+                            </Group>
+                        )}
+                    </Layer>
+                </Stage>
+            </div>
+
+            {/* Drag hint */}
+            <div className="map-hint">
+                <Move size={12} /> Drag to pan • Scroll to zoom
+            </div>
+        </div>
+    );
+};
+
+export default Map2DPlotter;

frontend/src/components/index.ts

@@ -0,0 +1,6 @@
+// Components index
+export { FileUploadPanel } from './FileUploadPanel';
+export { Map2DPlotter } from './Map2DPlotter';
+export { LayoutOptionsPanel } from './LayoutOptionsPanel';
+export { ChatInterface } from './ChatInterface';
+export { ExportPanel } from './ExportPanel';

frontend/src/index.css

@@ -0,0 +1,26 @@
+/* Base styles - reset default Vite styles */
+:root {
+  font-family: 'Inter', system-ui, -apple-system, BlinkMacSystemFont, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  margin: 0;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+#root {
+  min-height: 100vh;
+}

frontend/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/src/services/api.ts

@@ -0,0 +1,102 @@
+// API service for AIOptimize
+
+import axios from 'axios';
+import type {
+    UploadResponse,
+    GenerateResponse,
+    ChatResponse,
+    GeoJSONFeature
+} from '../types';
+
+const API_BASE = import.meta.env.VITE_API_URL || 'http://localhost:8000';
+
+const api = axios.create({
+    baseURL: API_BASE,
+    headers: {
+        'Content-Type': 'application/json',
+    },
+});
+
+export const apiService = {
+    // Health check
+    async health() {
+        const response = await api.get('/api/health');
+        return response.data;
+    },
+
+    // Get sample data
+    async getSampleData(): Promise<GeoJSONFeature> {
+        const response = await api.get('/api/sample-data');
+        return response.data;
+    },
+
+    // Upload boundary (JSON)
+    async uploadBoundary(geojson: GeoJSONFeature): Promise<UploadResponse> {
+        const response = await api.post('/api/upload-boundary-json', {
+            geojson: geojson,
+        });
+        return response.data;
+    },
+
+    // Upload boundary file (DXF or GeoJSON)
+    async uploadBoundaryFile(file: File): Promise<UploadResponse> {
+        const formData = new FormData();
+        formData.append('file', file);
+
+        // Use DXF endpoint for .dxf files
+        const isDxf = file.name.toLowerCase().endsWith('.dxf');
+        const endpoint = isDxf ? '/api/upload-dxf' : '/api/upload-boundary';
+
+        const response = await api.post(endpoint, formData, {
+            headers: { 'Content-Type': 'multipart/form-data' },
+        });
+        return response.data;
+    },
+
+    // Generate layouts
+    async generateLayouts(
+        sessionId: string,
+        targetPlots: number = 8,
+        setback: number = 50
+    ): Promise<GenerateResponse> {
+        const response = await api.post('/api/generate-layouts', {
+            session_id: sessionId,
+            target_plots: targetPlots,
+            setback: setback,
+        });
+        return response.data;
+    },
+
+    // Chat
+    async chat(sessionId: string, message: string): Promise<ChatResponse> {
+        const response = await api.post('/api/chat', {
+            session_id: sessionId,
+            message: message,
+        });
+        return response.data;
+    },
+
+    // Export DXF
+    async exportDxf(sessionId: string, optionId: number): Promise<Blob> {
+        const response = await api.post('/api/export-dxf', {
+            session_id: sessionId,
+            option_id: optionId,
+        }, {
+            responseType: 'blob',
+        });
+        return response.data;
+    },
+
+    // Export all as ZIP
+    async exportAllDxf(sessionId: string): Promise<Blob> {
+        const formData = new FormData();
+        formData.append('session_id', sessionId);
+
+        const response = await api.post('/api/export-all-dxf', formData, {
+            responseType: 'blob',
+        });
+        return response.data;
+    },
+};
+
+export default apiService;

frontend/src/types/index.ts

@@ -0,0 +1,86 @@
+// Type definitions for AIOptimize MVP
+
+export interface Coordinates {
+  x: number;
+  y: number;
+}
+
+export interface PlotData {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  area: number;
+  coords: number[][];
+}
+
+export interface LayoutMetrics {
+  total_plots: number;
+  total_area: number;
+  avg_size: number;
+  fitness: number;
+  compliance: string;
+}
+
+export interface LayoutOption {
+  id: number;
+  name: string;
+  icon: string;
+  description: string;
+  plots: PlotData[];
+  metrics: LayoutMetrics;
+}
+
+export interface SiteMetadata {
+  area: number;
+  perimeter: number;
+  bounds: number[];
+  centroid: number[];
+}
+
+export interface GeoJSONGeometry {
+  type: string;
+  coordinates: number[][][];
+}
+
+export interface GeoJSONFeature {
+  type: string;
+  geometry: GeoJSONGeometry;
+  properties?: Record<string, unknown>;
+}
+
+export interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+  model?: string;
+  timestamp?: string;
+}
+
+export interface UploadResponse {
+  session_id: string;
+  boundary: GeoJSONFeature;
+  metadata: SiteMetadata;
+}
+
+export interface GenerateResponse {
+  session_id: string;
+  options: LayoutOption[];
+  count: number;
+}
+
+export interface ChatResponse {
+  message: string;
+  model: 'gemini-2.0-flash' | 'fallback';
+}
+
+export interface AppState {
+  sessionId: string | null;
+  boundary: GeoJSONFeature | null;
+  boundaryCoords: number[][] | null;
+  metadata: SiteMetadata | null;
+  options: LayoutOption[];
+  selectedOption: number | null;
+  messages: ChatMessage[];
+  loading: boolean;
+  error: string | null;
+}

frontend/tsconfig.app.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

frontend/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

frontend/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

frontend/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

requirements.txt

@@ -0,0 +1,41 @@
+# REMB Dependencies - Industrial Estate Master Planning Optimization Engine
+
+# Core Optimization
+pymoo>=0.6.0
+ortools>=9.7.2876
+
+# Geometry Processing
+geopandas>=0.14.0
+shapely>=2.0.0
+ezdxf>=1.1.0
+pyproj>=3.6.0
+
+# API Framework
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.4.0
+pydantic-settings>=2.1.0
+python-multipart>=0.0.6
+
+# Database
+sqlalchemy>=2.0.0
+psycopg2-binary>=2.9.0
+geoalchemy2>=0.14.0
+alembic>=1.12.0
+
+# Data Processing
+numpy>=1.24.0
+pandas>=2.0.0
+pyyaml>=6.0
+
+# Utilities
+python-dotenv>=1.0.0
+pydantic>=2.4.0
+
+# Development & Testing
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+pytest-cov>=4.1.0
+black>=23.10.0
+flake8>=6.1.0
+mypy>=1.6.0

src/__init__.py

@@ -0,0 +1,7 @@
+"""
+REMB - Industrial Estate Master Planning Optimization Engine
+Main package initialization
+"""
+
+__version__ = "0.1.0"
+__author__ = "PiXerse.AI Team"

src/algorithms/__init__.py

@@ -0,0 +1 @@
+"""Algorithms package"""

src/algorithms/ga_optimizer.py

@@ -0,0 +1,405 @@
+"""
+Simple Genetic Algorithm Optimizer
+Generates 3 diverse layout options for industrial estate planning
+Following MVP-24h.md specification
+"""
+import random
+import math
+from typing import List, Dict, Tuple, Any
+from dataclasses import dataclass, field
+from shapely.geometry import Polygon, box, Point
+from shapely.ops import unary_union
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PlotConfig:
+    """Plot configuration"""
+    x: float
+    y: float
+    width: float
+    height: float
+    
+    @property
+    def area(self) -> float:
+        return self.width * self.height
+    
+    @property
+    def geometry(self) -> Polygon:
+        return box(self.x, self.y, self.x + self.width, self.y + self.height)
+    
+    def to_dict(self) -> Dict:
+        return {
+            "x": self.x,
+            "y": self.y,
+            "width": self.width,
+            "height": self.height,
+            "area": self.area,
+            "coords": list(self.geometry.exterior.coords)
+        }
+
+
+@dataclass
+class LayoutCandidate:
+    """A layout candidate in the GA population"""
+    plots: List[PlotConfig] = field(default_factory=list)
+    fitness: float = 0.0
+    
+    @property
+    def total_area(self) -> float:
+        return sum(p.area for p in self.plots)
+    
+    @property
+    def avg_plot_size(self) -> float:
+        return self.total_area / len(self.plots) if self.plots else 0
+    
+    def to_dict(self) -> Dict:
+        return {
+            "plots": [p.to_dict() for p in self.plots],
+            "total_plots": len(self.plots),
+            "total_area": self.total_area,
+            "avg_size": self.avg_plot_size,
+            "fitness": self.fitness
+        }
+
+
+class SimpleGAOptimizer:
+    """
+    Simple Genetic Algorithm for layout optimization
+    
+    Per MVP-24h.md:
+    - Population: 10 layouts
+    - Generations: 20
+    - Elite: 3 best
+    - Mutation rate: 30%
+    - Output: 3 diverse options
+    """
+    
+    def __init__(
+        self,
+        population_size: int = 10,
+        n_generations: int = 20,
+        elite_size: int = 3,
+        mutation_rate: float = 0.3,
+        setback: float = 50.0,
+        target_plots: int = 8
+    ):
+        self.population_size = population_size
+        self.n_generations = n_generations
+        self.elite_size = elite_size
+        self.mutation_rate = mutation_rate
+        self.setback = setback
+        self.target_plots = target_plots
+        
+        # Plot size ranges
+        self.min_plot_width = 30
+        self.max_plot_width = 80
+        self.min_plot_height = 40
+        self.max_plot_height = 100
+    
+    def optimize(self, boundary_coords: List[List[float]]) -> List[Dict]:
+        """
+        Run GA optimization and return 3 diverse layout options
+        
+        Args:
+            boundary_coords: List of [x, y] coordinate pairs
+            
+        Returns:
+            List of 3 layout options with different strategies
+        """
+        logger.info("Starting GA optimization")
+        
+        # Create boundary polygon
+        boundary = Polygon(boundary_coords)
+        if not boundary.is_valid:
+            boundary = boundary.buffer(0)
+        
+        # Get buildable area (after setback)
+        buildable = boundary.buffer(-self.setback)
+        if buildable.is_empty or not buildable.is_valid:
+            logger.warning("Buildable area too small, reducing setback")
+            buildable = boundary.buffer(-self.setback / 2)
+        
+        bounds = buildable.bounds  # (minx, miny, maxx, maxy)
+        
+        # Initialize population
+        population = self._initialize_population(buildable, bounds)
+        
+        # Evolution loop
+        for gen in range(self.n_generations):
+            # Evaluate fitness
+            for candidate in population:
+                candidate.fitness = self._evaluate_fitness(candidate, buildable, boundary)
+            
+            # Sort by fitness
+            population.sort(key=lambda x: x.fitness, reverse=True)
+            
+            # Keep elite
+            elite = population[:self.elite_size]
+            
+            # Create new population from elite
+            new_population = elite.copy()
+            
+            while len(new_population) < self.population_size:
+                parent = random.choice(elite)
+                child = self._mutate(parent, bounds, buildable)
+                new_population.append(child)
+            
+            population = new_population
+        
+        # Final sort
+        for candidate in population:
+            candidate.fitness = self._evaluate_fitness(candidate, buildable, boundary)
+        population.sort(key=lambda x: x.fitness, reverse=True)
+        
+        # Create 3 diverse options
+        options = self._create_diverse_options(population, buildable, bounds, boundary)
+        
+        logger.info(f"GA complete: {len(options)} options generated")
+        return options
+    
+    def _initialize_population(self, buildable: Polygon, bounds: Tuple) -> List[LayoutCandidate]:
+        """Create initial random population"""
+        population = []
+        minx, miny, maxx, maxy = bounds
+        
+        for _ in range(self.population_size):
+            candidate = LayoutCandidate()
+            placed = []
+            
+            for _ in range(self.target_plots):
+                # Random plot dimensions
+                width = random.uniform(self.min_plot_width, self.max_plot_width)
+                height = random.uniform(self.min_plot_height, self.max_plot_height)
+                
+                # Random position
+                for attempt in range(20):
+                    x = random.uniform(minx, maxx - width)
+                    y = random.uniform(miny, maxy - height)
+                    
+                    plot = PlotConfig(x=x, y=y, width=width, height=height)
+                    
+                    # Check if within buildable and no overlap
+                    if buildable.contains(plot.geometry):
+                        overlaps = False
+                        for existing in placed:
+                            if plot.geometry.intersects(existing.geometry):
+                                overlaps = True
+                                break
+                        
+                        if not overlaps:
+                            placed.append(plot)
+                            break
+                
+            candidate.plots = placed
+            population.append(candidate)
+        
+        return population
+    
+    def _evaluate_fitness(self, candidate: LayoutCandidate, buildable: Polygon, boundary: Polygon) -> float:
+        """
+        Evaluate fitness of a layout candidate
+        
+        Fitness = (Profit × 0.5) + (Compliance × 0.3) + (Efficiency × 0.2)
+        """
+        if not candidate.plots:
+            return 0.0
+        
+        # Profit score (normalized total area)
+        max_area = buildable.area * 0.6  # Max 60% coverage
+        profit = min(candidate.total_area / max_area, 1.0)
+        
+        # Compliance score (all plots within setback)
+        compliant = sum(1 for p in candidate.plots if buildable.contains(p.geometry))
+        compliance = compliant / len(candidate.plots)
+        
+        # Efficiency score (plot count vs target)
+        efficiency = min(len(candidate.plots) / self.target_plots, 1.0)
+        
+        fitness = (profit * 0.5) + (compliance * 0.3) + (efficiency * 0.2)
+        return round(fitness, 4)
+    
+    def _mutate(self, parent: LayoutCandidate, bounds: Tuple, buildable: Polygon) -> LayoutCandidate:
+        """Create mutated child from parent"""
+        child = LayoutCandidate()
+        minx, miny, maxx, maxy = bounds
+        
+        for plot in parent.plots:
+            if random.random() < self.mutation_rate:
+                # Mutate position (±30m)
+                new_x = plot.x + random.uniform(-30, 30)
+                new_y = plot.y + random.uniform(-30, 30)
+                
+                # Keep within bounds
+                new_x = max(minx, min(new_x, maxx - plot.width))
+                new_y = max(miny, min(new_y, maxy - plot.height))
+                
+                new_plot = PlotConfig(x=new_x, y=new_y, width=plot.width, height=plot.height)
+                
+                if buildable.contains(new_plot.geometry):
+                    child.plots.append(new_plot)
+                else:
+                    child.plots.append(plot)
+            else:
+                child.plots.append(plot)
+        
+        return child
+    
+    def _create_diverse_options(
+        self, 
+        population: List[LayoutCandidate],
+        buildable: Polygon,
+        bounds: Tuple,
+        boundary: Polygon
+    ) -> List[Dict]:
+        """
+        Create 3 diverse layout options:
+        1. Maximum Profit (most plots)
+        2. Balanced (medium density)
+        3. Premium (fewer, larger plots)
+        """
+        options = []
+        
+        # Option 1: Maximum Profit (best fitness from GA)
+        if population:
+            best = population[0]
+            options.append({
+                "id": 1,
+                "name": "Maximum Profit",
+                "icon": "💰",
+                "description": "Maximizes sellable area with more plots",
+                "plots": [p.to_dict() for p in best.plots],
+                "metrics": {
+                    "total_plots": len(best.plots),
+                    "total_area": round(best.total_area, 2),
+                    "avg_size": round(best.avg_plot_size, 2),
+                    "fitness": best.fitness,
+                    "compliance": "PASS"
+                }
+            })
+        
+        # Option 2: Balanced - Generate with medium density
+        balanced = self._generate_balanced_layout(buildable, bounds)
+        options.append({
+            "id": 2,
+            "name": "Balanced",
+            "icon": "⚖️",
+            "description": "Balanced approach with medium-sized plots",
+            "plots": [p.to_dict() for p in balanced.plots],
+            "metrics": {
+                "total_plots": len(balanced.plots),
+                "total_area": round(balanced.total_area, 2),
+                "avg_size": round(balanced.avg_plot_size, 2),
+                "fitness": self._evaluate_fitness(balanced, buildable, boundary),
+                "compliance": "PASS"
+            }
+        })
+        
+        # Option 3: Premium - Fewer, larger plots
+        premium = self._generate_premium_layout(buildable, bounds)
+        options.append({
+            "id": 3,
+            "name": "Premium",
+            "icon": "🏢",
+            "description": "Premium layout with fewer, larger plots",
+            "plots": [p.to_dict() for p in premium.plots],
+            "metrics": {
+                "total_plots": len(premium.plots),
+                "total_area": round(premium.total_area, 2),
+                "avg_size": round(premium.avg_plot_size, 2),
+                "fitness": self._evaluate_fitness(premium, buildable, boundary),
+                "compliance": "PASS"
+            }
+        })
+        
+        return options
+    
+    def _generate_balanced_layout(self, buildable: Polygon, bounds: Tuple) -> LayoutCandidate:
+        """Generate balanced layout with medium plot sizes"""
+        candidate = LayoutCandidate()
+        minx, miny, maxx, maxy = bounds
+        
+        # Medium plot size
+        plot_width = 50
+        plot_height = 70
+        spacing = 20
+        
+        placed = []
+        y = miny + spacing
+        
+        while y + plot_height < maxy:
+            x = minx + spacing
+            while x + plot_width < maxx:
+                plot = PlotConfig(x=x, y=y, width=plot_width, height=plot_height)
+                
+                if buildable.contains(plot.geometry):
+                    overlaps = False
+                    for existing in placed:
+                        if plot.geometry.intersects(existing.geometry):
+                            overlaps = True
+                            break
+                    
+                    if not overlaps:
+                        placed.append(plot)
+                
+                x += plot_width + spacing
+            y += plot_height + spacing
+        
+        candidate.plots = placed[:8]  # Limit to 8 plots
+        return candidate
+    
+    def _generate_premium_layout(self, buildable: Polygon, bounds: Tuple) -> LayoutCandidate:
+        """Generate premium layout with fewer, larger plots"""
+        candidate = LayoutCandidate()
+        minx, miny, maxx, maxy = bounds
+        
+        # Large plot size
+        plot_width = 80
+        plot_height = 100
+        spacing = 30
+        
+        placed = []
+        y = miny + spacing
+        
+        while y + plot_height < maxy and len(placed) < 4:
+            x = minx + spacing
+            while x + plot_width < maxx and len(placed) < 4:
+                plot = PlotConfig(x=x, y=y, width=plot_width, height=plot_height)
+                
+                if buildable.contains(plot.geometry):
+                    overlaps = False
+                    for existing in placed:
+                        if plot.geometry.intersects(existing.geometry):
+                            overlaps = True
+                            break
+                    
+                    if not overlaps:
+                        placed.append(plot)
+                
+                x += plot_width + spacing
+            y += plot_height + spacing
+        
+        candidate.plots = placed
+        return candidate
+
+
+# Example usage
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    # Sample boundary (simple rectangle)
+    boundary = [
+        [0, 0], [500, 0], [500, 400], [0, 400], [0, 0]
+    ]
+    
+    optimizer = SimpleGAOptimizer()
+    options = optimizer.optimize(boundary)
+    
+    for opt in options:
+        print(f"\n{opt['icon']} {opt['name']}")
+        print(f"   Plots: {opt['metrics']['total_plots']}")
+        print(f"   Area: {opt['metrics']['total_area']} m²")
+        print(f"   Avg: {opt['metrics']['avg_size']} m²")
+        print(f"   Fitness: {opt['metrics']['fitness']}")

src/algorithms/milp_solver.py

@@ -0,0 +1,659 @@
+"""
+MILP Solver - Module B: The Engineer (CP Module)
+Mixed-Integer Linear Programming solver for precision constraints using OR-Tools
+Đảm bảo tính hợp lệ toán học tuyệt đối - loại bỏ "hallucination"
+"""
+import numpy as np
+from ortools.linear_solver import pywraplp
+from ortools.sat.python import cp_model
+from typing import List, Tuple, Dict, Optional, Any
+from dataclasses import dataclass, field
+import json
+import logging
+
+from src.models.domain import Layout, Plot, PlotType, SiteBoundary, RoadNetwork
+from shapely.geometry import Polygon, box, LineString, MultiLineString
+from shapely.ops import unary_union
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MILPResult:
+    """Result from MILP solver"""
+    status: str  # 'OPTIMAL', 'FEASIBLE', 'INFEASIBLE', 'TIMEOUT'
+    objective_value: float = 0.0
+    solve_time_seconds: float = 0.0
+    plots: List[Dict[str, Any]] = field(default_factory=list)
+    error_message: Optional[str] = None
+    
+    def is_success(self) -> bool:
+        return self.status in ['OPTIMAL', 'FEASIBLE']
+    
+    def to_json(self) -> str:
+        """Export result as JSON for LLM interpretation"""
+        return json.dumps({
+            'status': self.status,
+            'objective_value': self.objective_value,
+            'solve_time_seconds': self.solve_time_seconds,
+            'num_plots': len(self.plots),
+            'plots': self.plots,
+            'error_message': self.error_message
+        }, indent=2)
+
+
+class MILPSolver:
+    """
+    Mixed-Integer Linear Programming Solver - The "Muscle/Kỹ sư"
+    
+    Responsibilities:
+    - Enforce non-overlapping constraints mathematically
+    - Ensure road connectivity for all plots
+    - Guarantee geometric closure and snapping
+    - Provide exact numerical solutions (no hallucination)
+    
+    This is a "black-box" that receives JSON parameters and returns raw results.
+    """
+    
+    def __init__(self, time_limit_seconds: int = 3600, solver_type: str = "SCIP"):
+        """
+        Initialize MILP Solver
+        
+        Args:
+            time_limit_seconds: Maximum solve time
+            solver_type: Solver backend ('SCIP', 'CBC', 'GLOP', 'SAT')
+        """
+        self.time_limit_seconds = time_limit_seconds
+        self.solver_type = solver_type
+        self.logger = logging.getLogger(__name__)
+        
+        # Try to find an available solver
+        self._available_solver = self._find_available_solver()
+    
+    def _find_available_solver(self) -> str:
+        """Find an available solver"""
+        solvers_to_try = [self.solver_type, 'SCIP', 'CBC', 'GLOP', 'SAT']
+        
+        for solver_name in solvers_to_try:
+            solver = pywraplp.Solver.CreateSolver(solver_name)
+            if solver:
+                self.logger.info(f"Using solver: {solver_name}")
+                return solver_name
+        
+        self.logger.warning("No LP solver available, will use CP-SAT only")
+        return None
+    
+    def validate_and_refine(self, layout: Layout) -> Tuple[Layout, MILPResult]:
+        """
+        Validate and refine a layout using MILP constraints
+        
+        This is the main entry point - receives layout, returns refined layout with
+        mathematically guaranteed validity.
+        
+        Args:
+            layout: Layout to validate and refine
+            
+        Returns:
+            Tuple of (refined_layout, result)
+        """
+        self.logger.info(f"MILP validation for layout {layout.id}")
+        import time
+        start_time = time.time()
+        
+        # Step 1: Check for overlaps and fix
+        overlap_result = self._resolve_overlaps(layout)
+        if not overlap_result.is_success():
+            return layout, overlap_result
+        
+        # Step 2: Ensure road connectivity
+        connectivity_result = self._ensure_road_connectivity(layout)
+        if not connectivity_result.is_success():
+            return layout, connectivity_result
+        
+        # Step 3: Snap geometries to grid
+        self._snap_geometries(layout)
+        
+        # Step 4: Validate final geometry closure
+        closure_result = self._validate_geometry_closure(layout)
+        
+        solve_time = time.time() - start_time
+        
+        result = MILPResult(
+            status='OPTIMAL' if closure_result else 'FEASIBLE',
+            objective_value=layout.metrics.sellable_area_sqm,
+            solve_time_seconds=solve_time,
+            plots=[{
+                'id': p.id,
+                'area_sqm': p.area_sqm,
+                'type': p.type.value,
+                'has_road_access': p.has_road_access
+            } for p in layout.plots]
+        )
+        
+        self.logger.info(f"MILP validation complete: {result.status} in {solve_time:.2f}s")
+        
+        return layout, result
+    
+    def _resolve_overlaps(self, layout: Layout) -> MILPResult:
+        """
+        Resolve plot overlaps using constraint programming
+        
+        Uses OR-Tools CP-SAT solver to find non-overlapping placement
+        """
+        industrial_plots = [p for p in layout.plots if p.type == PlotType.INDUSTRIAL]
+        
+        if len(industrial_plots) < 2:
+            return MILPResult(status='OPTIMAL')
+        
+        # Check for overlaps
+        overlaps_found = []
+        for i, p1 in enumerate(industrial_plots):
+            for p2 in industrial_plots[i+1:]:
+                if p1.geometry and p2.geometry:
+                    if p1.geometry.intersects(p2.geometry):
+                        intersection = p1.geometry.intersection(p2.geometry)
+                        if intersection.area > 1.0:  # 1 sqm tolerance
+                            overlaps_found.append((p1.id, p2.id, intersection.area))
+        
+        if not overlaps_found:
+            return MILPResult(status='OPTIMAL')
+        
+        self.logger.warning(f"Found {len(overlaps_found)} overlapping plot pairs")
+        
+        # Use CP-SAT to resolve overlaps
+        model = cp_model.CpModel()
+        
+        # Get site bounds
+        minx, miny, maxx, maxy = layout.site_boundary.geometry.bounds
+        site_width = int(maxx - minx)
+        site_height = int(maxy - miny)
+        
+        # Decision variables: position of each plot
+        plot_vars = {}
+        for plot in industrial_plots:
+            width = int(plot.width_m) if plot.width_m > 0 else 50
+            height = int(plot.depth_m) if plot.depth_m > 0 else 50
+            
+            # X and Y positions
+            x = model.NewIntVar(0, site_width - width, f'x_{plot.id}')
+            y = model.NewIntVar(0, site_height - height, f'y_{plot.id}')
+            
+            plot_vars[plot.id] = {
+                'x': x,
+                'y': y,
+                'width': width,
+                'height': height,
+                'plot': plot
+            }
+        
+        # Non-overlap constraints (using interval variables)
+        x_intervals = []
+        y_intervals = []
+        
+        for plot_id, vars in plot_vars.items():
+            x_interval = model.NewIntervalVar(
+                vars['x'],
+                vars['width'],
+                vars['x'] + vars['width'],
+                f'x_interval_{plot_id}'
+            )
+            y_interval = model.NewIntervalVar(
+                vars['y'],
+                vars['height'],
+                vars['y'] + vars['height'],
+                f'y_interval_{plot_id}'
+            )
+            x_intervals.append(x_interval)
+            y_intervals.append(y_interval)
+        
+        # Add 2D no-overlap constraint
+        model.AddNoOverlap2D(x_intervals, y_intervals)
+        
+        # Solve
+        solver = cp_model.CpSolver()
+        solver.parameters.max_time_in_seconds = min(60, self.time_limit_seconds)
+        
+        status = solver.Solve(model)
+        
+        if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+            # Update plot positions
+            for plot_id, vars in plot_vars.items():
+                new_x = solver.Value(vars['x']) + minx
+                new_y = solver.Value(vars['y']) + miny
+                width = vars['width']
+                height = vars['height']
+                
+                # Update plot geometry
+                plot = vars['plot']
+                plot.geometry = box(new_x, new_y, new_x + width, new_y + height)
+                plot.area_sqm = plot.geometry.area
+            
+            return MILPResult(
+                status='OPTIMAL' if status == cp_model.OPTIMAL else 'FEASIBLE',
+                solve_time_seconds=solver.WallTime()
+            )
+        else:
+            return MILPResult(
+                status='INFEASIBLE',
+                error_message='Cannot resolve overlaps - site may be too constrained'
+            )
+    
+    def _ensure_road_connectivity(self, layout: Layout) -> MILPResult:
+        """
+        Ensure all industrial plots have road access
+        
+        Uses simple distance-based connectivity check
+        """
+        max_distance = 200  # meters (from regulations)
+        
+        # If no road network, create a simple grid
+        if not layout.road_network or not layout.road_network.primary_roads:
+            self._generate_simple_road_network(layout)
+        
+        # Check connectivity for each industrial plot
+        disconnected_plots = []
+        all_roads = []
+        
+        if layout.road_network:
+            if layout.road_network.primary_roads:
+                all_roads.extend(layout.road_network.primary_roads.geoms if hasattr(layout.road_network.primary_roads, 'geoms') else [layout.road_network.primary_roads])
+            if layout.road_network.secondary_roads:
+                all_roads.extend(layout.road_network.secondary_roads.geoms if hasattr(layout.road_network.secondary_roads, 'geoms') else [layout.road_network.secondary_roads])
+        
+        for plot in layout.plots:
+            if plot.type == PlotType.INDUSTRIAL and plot.geometry:
+                # Find minimum distance to any road
+                min_distance = float('inf')
+                for road in all_roads:
+                    dist = plot.geometry.distance(road)
+                    min_distance = min(min_distance, dist)
+                
+                if min_distance <= max_distance:
+                    plot.has_road_access = True
+                else:
+                    plot.has_road_access = False
+                    disconnected_plots.append(plot.id)
+        
+        if disconnected_plots:
+            self.logger.warning(f"Plots without road access: {disconnected_plots}")
+            return MILPResult(
+                status='FEASIBLE',
+                error_message=f'Plots {disconnected_plots} exceed {max_distance}m from road'
+            )
+        
+        return MILPResult(status='OPTIMAL')
+    
+    def _generate_simple_road_network(self, layout: Layout):
+        """Generate a simple grid road network"""
+        bounds = layout.site_boundary.geometry.bounds
+        minx, miny, maxx, maxy = bounds
+        
+        # Create primary roads (cross pattern)
+        center_x = (minx + maxx) / 2
+        center_y = (miny + maxy) / 2
+        
+        horizontal = LineString([(minx, center_y), (maxx, center_y)])
+        vertical = LineString([(center_x, miny), (center_x, maxy)])
+        
+        layout.road_network = RoadNetwork(
+            primary_roads=MultiLineString([horizontal, vertical]),
+            total_length_m=horizontal.length + vertical.length
+        )
+        
+        # Calculate road area (assume 24m width for primary roads)
+        road_width = 24
+        road_area = layout.road_network.total_length_m * road_width
+        layout.road_network.total_area_sqm = road_area
+    
+    def _snap_geometries(self, layout: Layout, grid_size: float = 1.0):
+        """
+        Snap all geometries to a grid for clean coordinates
+        
+        Args:
+            layout: Layout to snap
+            grid_size: Grid size in meters (default 1m)
+        """
+        for plot in layout.plots:
+            if plot.geometry:
+                coords = list(plot.geometry.exterior.coords)
+                snapped_coords = [
+                    (round(x / grid_size) * grid_size, round(y / grid_size) * grid_size)
+                    for x, y in coords
+                ]
+                try:
+                    plot.geometry = Polygon(snapped_coords)
+                    plot.area_sqm = plot.geometry.area
+                except Exception as e:
+                    self.logger.warning(f"Failed to snap plot {plot.id}: {e}")
+    
+    def _validate_geometry_closure(self, layout: Layout) -> bool:
+        """
+        Validate that all geometries are properly closed
+        
+        Returns:
+            True if all geometries are valid
+        """
+        all_valid = True
+        
+        for plot in layout.plots:
+            if plot.geometry:
+                if not plot.geometry.is_valid:
+                    self.logger.warning(f"Plot {plot.id} has invalid geometry")
+                    # Try to fix
+                    plot.geometry = plot.geometry.buffer(0)
+                    if not plot.geometry.is_valid:
+                        all_valid = False
+        
+        return all_valid
+    
+    def solve_plot_placement(
+        self,
+        site_boundary: SiteBoundary,
+        num_plots: int,
+        min_plot_size: float = 1000,
+        max_plot_size: float = 10000,
+        setback: float = 50
+    ) -> MILPResult:
+        """
+        Solve optimal plot placement from scratch using MILP
+        
+        This is the "black-box" function that LLM can call via Function Calling.
+        Receives JSON-like parameters, returns raw numerical results.
+        
+        Args:
+            site_boundary: Site boundary polygon
+            num_plots: Target number of plots
+            min_plot_size: Minimum plot area in sqm
+            max_plot_size: Maximum plot area in sqm
+            setback: Boundary setback in meters
+            
+        Returns:
+            MILPResult with plot placements
+        """
+        self.logger.info(f"MILP solving for {num_plots} plots")
+        import time
+        start_time = time.time()
+        
+        # Create solver - use available solver or fallback to CP-SAT
+        solver_to_use = self._available_solver or 'SAT'
+        solver = pywraplp.Solver.CreateSolver(solver_to_use)
+        if not solver:
+            # Fallback: Use CP-SAT based approach
+            return self._solve_with_cpsat(site_boundary, num_plots, min_plot_size, max_plot_size, setback)
+        
+        solver.SetTimeLimit(self.time_limit_seconds * 1000)  # Convert to ms
+        
+        # Get buildable area (after setback)
+        buildable = site_boundary.geometry.buffer(-setback)
+        if buildable.is_empty:
+            return MILPResult(
+                status='INFEASIBLE',
+                error_message=f'Site too small for {setback}m setback'
+            )
+        
+        bounds = buildable.bounds
+        minx, miny, maxx, maxy = bounds
+        width = maxx - minx
+        height = maxy - miny
+        
+        # Decision variables
+        infinity = solver.infinity()
+        
+        # For each plot: x, y, w, h (continuous), active (binary)
+        plots_vars = []
+        for i in range(num_plots):
+            x = solver.NumVar(0, width, f'x_{i}')
+            y = solver.NumVar(0, height, f'y_{i}')
+            w = solver.NumVar(20, 200, f'w_{i}')  # 20-200m width
+            h = solver.NumVar(20, 200, f'h_{i}')  # 20-200m height
+            active = solver.IntVar(0, 1, f'active_{i}')
+            
+            plots_vars.append({
+                'x': x, 'y': y, 'w': w, 'h': h,
+                'active': active, 'index': i
+            })
+            
+            # Boundary constraints
+            solver.Add(x + w <= width)
+            solver.Add(y + h <= height)
+            
+            # Size constraints
+            solver.Add(w * h >= min_plot_size * active)
+            solver.Add(w * h <= max_plot_size)
+        
+        # Objective: Maximize total active plot area
+        objective = solver.Objective()
+        for pv in plots_vars:
+            # Approximate area (linearization)
+            objective.SetCoefficient(pv['w'], 100)
+            objective.SetCoefficient(pv['h'], 100)
+            objective.SetCoefficient(pv['active'], min_plot_size)
+        objective.SetMaximization()
+        
+        # Solve
+        status = solver.Solve()
+        
+        solve_time = time.time() - start_time
+        
+        # Parse results
+        if status in [pywraplp.Solver.OPTIMAL, pywraplp.Solver.FEASIBLE]:
+            result_plots = []
+            for pv in plots_vars:
+                if pv['active'].solution_value() > 0.5:
+                    x = pv['x'].solution_value() + minx + setback
+                    y = pv['y'].solution_value() + miny + setback
+                    w = pv['w'].solution_value()
+                    h = pv['h'].solution_value()
+                    
+                    result_plots.append({
+                        'id': f'plot_{pv["index"]}',
+                        'x': x,
+                        'y': y,
+                        'width': w,
+                        'height': h,
+                        'area_sqm': w * h,
+                        'type': 'industrial'
+                    })
+            
+            return MILPResult(
+                status='OPTIMAL' if status == pywraplp.Solver.OPTIMAL else 'FEASIBLE',
+                objective_value=solver.Objective().Value(),
+                solve_time_seconds=solve_time,
+                plots=result_plots
+            )
+        else:
+            status_map = {
+                pywraplp.Solver.INFEASIBLE: 'INFEASIBLE',
+                pywraplp.Solver.UNBOUNDED: 'UNBOUNDED',
+                pywraplp.Solver.NOT_SOLVED: 'TIMEOUT'
+            }
+            return MILPResult(
+                status=status_map.get(status, 'ERROR'),
+                solve_time_seconds=solve_time,
+                error_message='Could not find valid plot placement'
+            )
+    
+    def _solve_with_cpsat(
+        self,
+        site_boundary: SiteBoundary,
+        num_plots: int,
+        min_plot_size: float,
+        max_plot_size: float,
+        setback: float
+    ) -> MILPResult:
+        """
+        Fallback solver using CP-SAT for plot placement
+        """
+        import time
+        start_time = time.time()
+        
+        # Get buildable area
+        buildable = site_boundary.geometry.buffer(-setback)
+        if buildable.is_empty:
+            return MILPResult(
+                status='INFEASIBLE',
+                error_message=f'Site too small for {setback}m setback'
+            )
+        
+        minx, miny, maxx, maxy = buildable.bounds
+        width = int(maxx - minx)
+        height = int(maxy - miny)
+        
+        # Use CP-SAT
+        model = cp_model.CpModel()
+        
+        # Fixed plot dimensions for simplicity
+        plot_width = int(min_plot_size ** 0.5)  # Square plots
+        plot_height = plot_width
+        
+        # Create plot variables
+        plot_vars = []
+        x_intervals = []
+        y_intervals = []
+        
+        for i in range(num_plots):
+            x = model.NewIntVar(0, max(0, width - plot_width), f'x_{i}')
+            y = model.NewIntVar(0, max(0, height - plot_height), f'y_{i}')
+            
+            x_interval = model.NewIntervalVar(x, plot_width, x + plot_width, f'x_int_{i}')
+            y_interval = model.NewIntervalVar(y, plot_height, y + plot_height, f'y_int_{i}')
+            
+            plot_vars.append({'x': x, 'y': y, 'width': plot_width, 'height': plot_height})
+            x_intervals.append(x_interval)
+            y_intervals.append(y_interval)
+        
+        # No overlap constraint
+        model.AddNoOverlap2D(x_intervals, y_intervals)
+        
+        # Solve
+        solver = cp_model.CpSolver()
+        solver.parameters.max_time_in_seconds = min(30, self.time_limit_seconds)
+        status = solver.Solve(model)
+        
+        solve_time = time.time() - start_time
+        
+        if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+            result_plots = []
+            for i, pv in enumerate(plot_vars):
+                x = solver.Value(pv['x']) + minx + setback
+                y = solver.Value(pv['y']) + miny + setback
+                
+                result_plots.append({
+                    'id': f'plot_{i}',
+                    'x': x,
+                    'y': y,
+                    'width': pv['width'],
+                    'height': pv['height'],
+                    'area_sqm': pv['width'] * pv['height'],
+                    'type': 'industrial'
+                })
+            
+            return MILPResult(
+                status='OPTIMAL' if status == cp_model.OPTIMAL else 'FEASIBLE',
+                objective_value=len(result_plots) * plot_width * plot_height,
+                solve_time_seconds=solve_time,
+                plots=result_plots
+            )
+        else:
+            return MILPResult(
+                status='INFEASIBLE',
+                solve_time_seconds=solve_time,
+                error_message='Could not place plots without overlap'
+            )
+
+    def to_json_interface(self, request: Dict[str, Any]) -> str:
+        """
+        JSON interface for LLM Function Calling
+        
+        This is the standardized interface that LLM uses to call the CP Module.
+        
+        Input format:
+        {
+            "action": "solve_placement" | "validate_layout",
+            "parameters": {...}
+        }
+        
+        Output format:
+        {
+            "status": "OPTIMAL" | "FEASIBLE" | "INFEASIBLE" | "ERROR",
+            "result": {...}
+        }
+        """
+        action = request.get('action')
+        params = request.get('parameters', {})
+        
+        try:
+            if action == 'solve_placement':
+                # Create site boundary from params
+                bounds = params.get('bounds', [0, 0, 500, 500])
+                site_geom = box(*bounds)
+                site = SiteBoundary(geometry=site_geom, area_sqm=site_geom.area)
+                
+                result = self.solve_plot_placement(
+                    site_boundary=site,
+                    num_plots=params.get('num_plots', 10),
+                    min_plot_size=params.get('min_plot_size', 1000),
+                    max_plot_size=params.get('max_plot_size', 10000),
+                    setback=params.get('setback', 50)
+                )
+                
+            elif action == 'validate_layout':
+                # Would need to deserialize layout from JSON
+                return json.dumps({
+                    'status': 'ERROR',
+                    'error_message': 'validate_layout requires Layout object'
+                })
+            else:
+                return json.dumps({
+                    'status': 'ERROR',
+                    'error_message': f'Unknown action: {action}'
+                })
+            
+            return result.to_json()
+            
+        except Exception as e:
+            return json.dumps({
+                'status': 'ERROR',
+                'error_message': str(e)
+            })
+
+
+# Example usage
+if __name__ == "__main__":
+    from shapely.geometry import box as shapely_box
+    
+    # Create test site
+    site_geom = shapely_box(0, 0, 500, 500)
+    site = SiteBoundary(geometry=site_geom, area_sqm=site_geom.area)
+    site.buildable_area_sqm = site.area_sqm
+    
+    # Test MILP solver
+    solver = MILPSolver(time_limit_seconds=60)
+    
+    # Test plot placement
+    result = solver.solve_plot_placement(
+        site_boundary=site,
+        num_plots=10,
+        min_plot_size=1000,
+        max_plot_size=5000,
+        setback=50
+    )
+    
+    print(f"Status: {result.status}")
+    print(f"Solve time: {result.solve_time_seconds:.2f}s")
+    print(f"Number of plots: {len(result.plots)}")
+    
+    # Test JSON interface
+    json_request = {
+        "action": "solve_placement",
+        "parameters": {
+            "bounds": [0, 0, 500, 500],
+            "num_plots": 10,
+            "min_plot_size": 1000,
+            "setback": 50
+        }
+    }
+    
+    json_response = solver.to_json_interface(json_request)
+    print("\nJSON Response:")
+    print(json_response)

src/algorithms/nsga2_optimizer.py

@@ -0,0 +1,336 @@
+"""
+NSGA-II Optimizer - Module A: The Architect
+Multi-objective genetic algorithm for industrial estate layout optimization
+"""
+import numpy as np
+from pymoo.algorithms.moo.nsga2 import NSGA2
+from pymoo.core.problem import Problem
+from pymoo.optimize import minimize
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from typing import List, Tuple
+import yaml
+from pathlib import Path
+
+from src.models.domain import Layout, SiteBoundary, Plot, PlotType, ParetoFront, RoadNetwork
+from shapely.geometry import Polygon, box
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class IndustrialEstateProblem(Problem):
+    """
+    Multi-objective optimization problem for industrial estate layout
+    
+    Objectives:
+    1. Maximize sellable area
+    2. Maximize green space
+    3. Minimize road network length
+    4. Maximize regulatory compliance score
+    """
+    
+    def __init__(self, site_boundary: SiteBoundary, regulations: dict, n_plots: int = 20):
+        """
+        Initialize optimization problem
+        
+        Args:
+            site_boundary: Site boundary with constraints
+            regulations: Regulatory requirements from YAML
+            n_plots: Target number of industrial plots
+        """
+        self.site_boundary = site_boundary
+        self.regulations = regulations
+        self.n_plots = n_plots
+        
+        # Decision variables: [x1, y1, width1, height1, orientation1, ..., xN, yN, widthN, heightN, orientationN]
+        # 5 variables per plot: x, y position (normalized), width, height (meters), orientation (0-360)
+        n_var = n_plots * 5
+        
+        # Variable bounds
+        xl = np.array([0, 0, 20, 20, 0] * n_plots)  # Lower bounds
+        xu = np.array([1, 1, 200, 200, 360] * n_plots)  # Upper bounds
+        
+        super().__init__(
+            n_var=n_var,
+            n_obj=4,  # 4 objectives
+            n_constr=0,  # Constraints handled via penalties
+            xl=xl,
+            xu=xu
+        )
+    
+    def _evaluate(self, X, out, *args, **kwargs):
+        """
+        Evaluate population
+        
+        Args:
+            X: Population matrix (n_individuals x n_variables)
+            out: Output dictionary
+        """
+        n_individuals = X.shape[0]
+        
+        # Initialize objective arrays
+        f1_sellable = np.zeros(n_individuals)  # Maximize (will negate)
+        f2_green = np.zeros(n_individuals)  # Maximize (will negate)
+        f3_road_length = np.zeros(n_individuals)  # Minimize
+        f4_compliance = np.zeros(n_individuals)  # Maximize (will negate)
+        
+        for i in range(n_individuals):
+            layout = self._decode_solution(X[i])
+            
+            # Calculate objectives
+            metrics = layout.calculate_metrics()
+            
+            # F1: Maximize sellable area (negate for minimization)
+            f1_sellable[i] = -metrics.sellable_area_sqm
+            
+            # F2: Maximize green space (negate for minimization)
+            f2_green[i] = -metrics.green_space_area_sqm
+            
+            # F3: Minimize road network length
+            if layout.road_network:
+                f3_road_length[i] = layout.road_network.total_length_m
+            else:
+                f3_road_length[i] = 1e6  # Penalty for no road
+            
+            # F4: Regulatory compliance score (0-1, higher is better)
+            compliance_score = self._calculate_compliance_score(layout)
+            f4_compliance[i] = -compliance_score  # Negate for minimization
+        
+        # Set objectives
+        out["F"] = np.column_stack([f1_sellable, f2_green, f3_road_length, f4_compliance])
+    
+    def _decode_solution(self, x: np.ndarray) -> Layout:
+        """
+        Decode decision variables into a Layout
+        
+        Args:
+            x: Decision variables array
+            
+        Returns:
+            Layout object
+        """
+        layout = Layout(site_boundary=self.site_boundary)
+        
+        # Get site bounds for denormalization
+        minx, miny, maxx, maxy = self.site_boundary.geometry.bounds
+        site_width = maxx - minx
+        site_height = maxy - miny
+        
+        plots = []
+        for i in range(self.n_plots):
+            idx = i * 5
+            
+            # Denormalize position
+            x_norm, y_norm = x[idx], x[idx + 1]
+            x_pos = minx + x_norm * site_width
+            y_pos = miny + y_norm * site_height
+            
+            width, height = x[idx + 2], x[idx + 3]
+            orientation = x[idx + 4]
+            
+            # Create simple rectangular plot
+            plot_geom = box(x_pos, y_pos, x_pos + width, y_pos + height)
+            
+            # Check if plot is within buildable area
+            if not self.site_boundary.geometry.contains(plot_geom):
+                continue  # Skip invalid plots
+            
+            plot = Plot(
+                geometry=plot_geom,
+                area_sqm=plot_geom.area,
+                type=PlotType.INDUSTRIAL,
+                width_m=width,
+                depth_m=height,
+                orientation_degrees=orientation
+            )
+            plots.append(plot)
+        
+        # Add green space (simplified: use remaining area)
+        # In practice, this would be more sophisticated
+        green_area_target = self.site_boundary.buildable_area_sqm * 0.15  # 15% minimum
+        
+        layout.plots = plots
+        layout.road_network = RoadNetwork()  # Simplified
+        
+        return layout
+    
+    def _calculate_compliance_score(self, layout: Layout) -> float:
+        """
+        Calculate regulatory compliance score (0-1)
+        
+        Args:
+            layout: Layout to evaluate
+            
+        Returns:
+            Compliance score (1.0 = fully compliant)
+        """
+        score = 1.0
+        penalties = 0
+        
+        metrics = layout.metrics
+        
+        # Check green space requirement
+        min_green = self.regulations.get('green_space', {}).get('minimum_percentage', 0.15)
+        if metrics.green_space_ratio < min_green:
+            penalties += 0.3
+        
+        # Check FAR
+        max_far = self.regulations.get('far', {}).get('maximum', 0.7)
+        if metrics.far_value > max_far:
+            penalties += 0.3
+        
+        # Check plot sizes
+        min_plot_size = self.regulations.get('plot', {}).get('minimum_area_sqm', 1000)
+        for plot in layout.plots:
+            if plot.type == PlotType.INDUSTRIAL and plot.area_sqm < min_plot_size:
+                penalties += 0.1
+                break
+        
+        score = max(0.0, score - penalties)
+        return score
+
+
+class NSGA2Optimizer:
+    """
+    NSGA-II based multi-objective optimizer for industrial estate layouts
+    """
+    
+    def __init__(self, config_path: str = "config/regulations.yaml"):
+        """
+        Initialize optimizer
+        
+        Args:
+            config_path: Path to regulations YAML file
+        """
+        self.config_path = Path(config_path)
+        self.regulations = self._load_regulations()
+        self.logger = logging.getLogger(__name__)
+    
+    def _load_regulations(self) -> dict:
+        """Load regulations from YAML file"""
+        if not self.config_path.exists():
+            self.logger.warning(f"Regulations file not found: {self.config_path}")
+            return {}
+        
+        with open(self.config_path, 'r', encoding='utf-8') as f:
+            return yaml.safe_load(f)
+    
+    def optimize(
+        self,
+        site_boundary: SiteBoundary,
+        population_size: int = 100,
+        n_generations: int = 200,
+        n_plots: int = 20
+    ) -> ParetoFront:
+        """
+        Run NSGA-II optimization
+        
+        Args:
+            site_boundary: Site boundary with constraints
+            population_size: NSGA-II population size
+            n_generations: Number of generations
+            n_plots: Target number of plots
+            
+        Returns:
+            ParetoFront with optimal solutions
+        """
+        import time
+        start_time = time.time()
+        
+        self.logger.info(f"Starting NSGA-II optimization: pop={population_size}, gen={n_generations}")
+        
+        # Define problem
+        problem = IndustrialEstateProblem(
+            site_boundary=site_boundary,
+            regulations=self.regulations,
+            n_plots=n_plots
+        )
+        
+        # Define algorithm
+        algorithm = NSGA2(
+            pop_size=population_size,
+            sampling=FloatRandomSampling(),
+            crossover=SBX(prob=0.9, eta=15),
+            mutation=PM(eta=20),
+            eliminate_duplicates=True
+        )
+        
+        # Run optimization
+        result = minimize(
+            problem,
+            algorithm,
+            ('n_gen', n_generations),
+            seed=42,
+            verbose=True
+        )
+        
+        # Extract Pareto front
+        pareto_front = ParetoFront()
+        
+        if result.X is not None:
+            # result.X can be 1D or 2D depending on number of solutions
+            if len(result.X.shape) == 1:
+                solutions = [result.X]
+            else:
+                solutions = result.X
+            
+            for i, x in enumerate(solutions):
+                layout = problem._decode_solution(x)
+                layout.pareto_rank = i
+                layout.calculate_metrics()
+                
+                # Store fitness scores
+                if len(result.F.shape) == 1:
+                    f = result.F
+                else:
+                    f = result.F[i]
+                
+                layout.fitness_scores = {
+                    'sellable_area': -f[0],  # Negate back
+                    'green_space': -f[1],
+                    'road_length': f[2],
+                    'compliance': -f[3]
+                }
+                
+                pareto_front.layouts.append(layout)
+        
+        pareto_front.generation_time_seconds = time.time() - start_time
+        
+        self.logger.info(f"Optimization complete: {len(pareto_front.layouts)} solutions in {pareto_front.generation_time_seconds:.2f}s")
+        
+        return pareto_front
+
+
+# Example usage
+if __name__ == "__main__":
+    # Example: Create a simple rectangular site
+    from shapely.geometry import box
+    
+    site_geom = box(0, 0, 500, 500)  # 500m x 500m site
+    site = SiteBoundary(
+        geometry=site_geom,
+        area_sqm=site_geom.area
+    )
+    site.buildable_area_sqm = site.area_sqm
+    
+    # Run optimization
+    optimizer = NSGA2Optimizer()
+    pareto_front = optimizer.optimize(
+        site_boundary=site,
+        population_size=50,
+        n_generations=100,
+        n_plots=15
+    )
+    
+    print(f"Generated {len(pareto_front.layouts)} Pareto-optimal layouts")
+    
+    # Show best layouts
+    max_sellable = pareto_front.get_max_sellable_layout()
+    if max_sellable:
+        print(f"Max sellable area: {max_sellable.metrics.sellable_area_sqm:.2f} m²")
+    
+    max_green = pareto_front.get_max_green_layout()
+    if max_green:
+        print(f"Max green space: {max_green.metrics.green_space_area_sqm:.2f} m²")

src/algorithms/regulation_checker.py

@@ -0,0 +1,329 @@
+"""
+Regulation Checker - Module C: The Inspector
+Rule-based expert system for Vietnamese industrial estate regulatory compliance
+"""
+import yaml
+from pathlib import Path
+from typing import List, Dict
+import logging
+from shapely.geometry import Polygon, MultiPolygon, Point
+from shapely.ops import unary_union
+import geopandas as gpd
+
+from src.models.domain import Layout, Plot, PlotType, ComplianceReport, Constraint, ConstraintType
+
+logger = logging.getLogger(__name__)
+
+
+class RegulationChecker:
+    """
+    Automated regulatory compliance checker for industrial estate layouts
+    Based on Vietnamese industrial estate regulations
+    """
+    
+    def __init__(self, regulations_path: str = "config/regulations.yaml"):
+        """
+        Initialize regulation checker
+        
+        Args:
+            regulations_path: Path to regulations YAML configuration
+        """
+        self.regulations_path = Path(regulations_path)
+        self.regulations = self._load_regulations()
+        self.logger = logging.getLogger(__name__)
+    
+    def _load_regulations(self) -> dict:
+        """Load regulations from YAML file"""
+        if not self.regulations_path.exists():
+            self.logger.warning(f"Regulations file not found: {self.regulations_path}")
+            return self._get_default_regulations()
+        
+        with open(self.regulations_path, 'r', encoding='utf-8') as f:
+            return yaml.safe_load(f)
+    
+    def _get_default_regulations(self) -> dict:
+        """Get default regulations if file not found"""
+        return {
+            'setbacks': {
+                'boundary_minimum': 50,
+                'fire_safety_distance': 30,
+                'waterway_buffer': 100
+            },
+            'far': {
+                'maximum': 0.7,
+                'minimum': 0.3
+            },
+            'green_space': {
+                'minimum_percentage': 0.15
+            },
+            'plot': {
+                'minimum_area_sqm': 1000,
+                'minimum_width_m': 20
+            },
+            'roads': {
+                'maximum_distance_to_road_m': 200
+            }
+        }
+    
+    def validate_compliance(self, layout: Layout) -> ComplianceReport:
+        """
+        Comprehensive regulatory compliance validation
+        
+        Args:
+            layout: Layout to validate
+            
+        Returns:
+            ComplianceReport with violations and warnings
+        """
+        report = ComplianceReport(
+            layout_id=layout.id,
+            is_compliant=True
+        )
+        
+        self.logger.info(f"Validating layout {layout.id} against Vietnamese regulations")
+        
+        # Run all checks
+        self._check_boundary_setbacks(layout, report)
+        self._check_far_compliance(layout, report)
+        self._check_green_space_requirements(layout, report)
+        self._check_plot_dimensions(layout, report)
+        self._check_road_accessibility(layout, report)
+        self._check_fire_safety_distances(layout, report)
+        self._check_no_overlaps(layout, report)
+        
+        # Final determination
+        if len(report.violations) == 0:
+            report.is_compliant = True
+            self.logger.info(f"Layout {layout.id} is COMPLIANT")
+        else:
+            report.is_compliant = False
+            self.logger.warning(f"Layout {layout.id} has {len(report.violations)} violations")
+        
+        return report
+    
+    def _check_boundary_setbacks(self, layout: Layout, report: ComplianceReport):
+        """Check minimum setback from site boundary"""
+        min_setback = self.regulations['setbacks']['boundary_minimum']
+        
+        # Create buffer zone inside boundary
+        boundary = layout.site_boundary.geometry
+        setback_zone = boundary.buffer(-min_setback)
+        
+        for plot in layout.plots:
+            if plot.type == PlotType.INDUSTRIAL:
+                if not setback_zone.contains(plot.geometry):
+                    report.add_violation(
+                        f"Plot {plot.id} violates {min_setback}m boundary setback requirement"
+                    )
+                    return
+        
+        report.add_pass("Boundary setback compliance")
+    
+    def _check_far_compliance(self, layout: Layout, report: ComplianceReport):
+        """Check Floor Area Ratio (FAR) compliance"""
+        max_far = self.regulations['far']['maximum']
+        min_far = self.regulations['far'].get('minimum', 0.0)
+        
+        metrics = layout.metrics
+        
+        # FAR = Total floor area / Land area
+        # Simplified: assuming single story, FAR = Building area / Land area
+        if metrics.sellable_ratio > max_far:
+            report.add_violation(
+                f"FAR {metrics.sellable_ratio:.2f} exceeds maximum {max_far}"
+            )
+        elif metrics.sellable_ratio < min_far:
+            report.add_warning(
+                f"FAR {metrics.sellable_ratio:.2f} below recommended minimum {min_far}"
+            )
+        else:
+            report.add_pass(f"FAR compliance ({metrics.sellable_ratio:.2f})")
+    
+    def _check_green_space_requirements(self, layout: Layout, report: ComplianceReport):
+        """Check minimum green space requirement"""
+        min_green = self.regulations['green_space']['minimum_percentage']
+        
+        metrics = layout.metrics
+        
+        if metrics.green_space_ratio < min_green:
+            deficit = (min_green - metrics.green_space_ratio) * 100
+            report.add_violation(
+                f"Green space {metrics.green_space_ratio*100:.1f}% is below minimum {min_green*100}% "
+                f"(deficit: {deficit:.1f}%)"
+            )
+        else:
+            report.add_pass(f"Green space compliance ({metrics.green_space_ratio*100:.1f}%)")
+    
+    def _check_plot_dimensions(self, layout: Layout, report: ComplianceReport):
+        """Check plot minimum dimensions"""
+        min_area = self.regulations['plot']['minimum_area_sqm']
+        min_width = self.regulations['plot']['minimum_width_m']
+        
+        violations = []
+        for plot in layout.plots:
+            if plot.type == PlotType.INDUSTRIAL:
+                if plot.area_sqm < min_area:
+                    violations.append(
+                        f"Plot {plot.id} area {plot.area_sqm:.0f}m² below minimum {min_area}m²"
+                    )
+                
+                if plot.width_m < min_width:
+                    violations.append(
+                        f"Plot {plot.id} width {plot.width_m:.1f}m below minimum {min_width}m"
+                    )
+        
+        if violations:
+            for v in violations:
+                report.add_violation(v)
+        else:
+            report.add_pass("Plot dimension compliance")
+    
+    def _check_road_accessibility(self, layout: Layout, report: ComplianceReport):
+        """Check that all plots have road access within maximum distance"""
+        max_distance = self.regulations['roads']['maximum_distance_to_road_m']
+        
+        if not layout.road_network or not layout.road_network.primary_roads:
+            report.add_warning("No road network defined for accessibility check")
+            return
+        
+        # Simplified check: ensure plots are within max_distance of roads
+        # In practice, would check actual road connectivity
+        
+        violations = []
+        for plot in layout.plots:
+            if plot.type == PlotType.INDUSTRIAL:
+                if not plot.has_road_access:
+                    violations.append(f"Plot {plot.id} lacks road access")
+        
+        if violations:
+            for v in violations:
+                report.add_violation(v)
+        else:
+            report.add_pass("Road accessibility compliance")
+    
+    def _check_fire_safety_distances(self, layout: Layout, report: ComplianceReport):
+        """Check fire safety distance requirements"""
+        fire_distance = self.regulations['setbacks']['fire_safety_distance']
+        
+        # Check spacing between industrial plots
+        industrial_plots = [p for p in layout.plots if p.type == PlotType.INDUSTRIAL]
+        
+        for i, plot1 in enumerate(industrial_plots):
+            for plot2 in industrial_plots[i+1:]:
+                distance = plot1.geometry.distance(plot2.geometry)
+                if distance < fire_distance:
+                    report.add_violation(
+                        f"Plots {plot1.id} and {plot2.id} violate {fire_distance}m fire safety distance "
+                        f"(actual: {distance:.1f}m)"
+                    )
+                    return
+        
+        report.add_pass("Fire safety distance compliance")
+    
+    def _check_no_overlaps(self, layout: Layout, report: ComplianceReport):
+        """Check that no plots overlap"""
+        plots = layout.plots
+        
+        for i, plot1 in enumerate(plots):
+            for plot2 in plots[i+1:]:
+                if plot1.geometry.intersects(plot2.geometry):
+                    intersection = plot1.geometry.intersection(plot2.geometry)
+                    if intersection.area > 0.01:  # Small tolerance for numerical errors
+                        report.add_violation(
+                            f"Plots {plot1.id} and {plot2.id} overlap by {intersection.area:.2f}m²"
+                        )
+                        return
+        
+        report.add_pass("No plot overlaps")
+    
+    def check_constraint_compliance(self, layout: Layout, constraints: List[Constraint]) -> ComplianceReport:
+        """
+        Check compliance against specific spatial constraints
+        
+        Args:
+            layout: Layout to check
+            constraints: List of spatial constraints
+            
+        Returns:
+            ComplianceReport
+        """
+        report = ComplianceReport(
+            layout_id=layout.id,
+            is_compliant=True
+        )
+        
+        for constraint in constraints:
+            violations = self._check_single_constraint(layout, constraint)
+            for v in violations:
+                report.add_violation(v)
+        
+        return report
+    
+    def _check_single_constraint(self, layout: Layout, constraint: Constraint) -> List[str]:
+        """Check a single constraint"""
+        violations = []
+        
+        for plot in layout.plots:
+            if plot.type == PlotType.INDUSTRIAL:
+                if plot.geometry.intersects(constraint.geometry):
+                    violations.append(
+                        f"Plot {plot.id} violates {constraint.type.value} constraint: {constraint.description}"
+                    )
+        
+        return violations
+
+
+# Example usage
+if __name__ == "__main__":
+    from shapely.geometry import box
+    from src.models.domain import SiteBoundary
+    
+    # Create example site and layout
+    site_geom = box(0, 0, 500, 500)
+    site = SiteBoundary(geometry=site_geom, area_sqm=site_geom.area)
+    site.buildable_area_sqm = site.area_sqm
+    
+    layout = Layout(site_boundary=site)
+    
+    # Add some example plots
+    plot1 = Plot(
+        geometry=box(60, 60, 150, 150),
+        area_sqm=8100,
+        type=PlotType.INDUSTRIAL,
+        width_m=90,
+        depth_m=90,
+        has_road_access=True
+    )
+    
+    plot2 = Plot(
+        geometry=box(200, 60, 290, 150),
+        area_sqm=8100,
+        type=PlotType.INDUSTRIAL,
+        width_m=90,
+        depth_m=90,
+        has_road_access=True
+    )
+    
+    green_plot = Plot(
+        geometry=box(60, 200, 150, 290),
+        area_sqm=8100,
+        type=PlotType.GREEN_SPACE
+    )
+    
+    layout.plots = [plot1, plot2, green_plot]
+    layout.calculate_metrics()
+    
+    # Check compliance
+    checker = RegulationChecker()
+    report = checker.validate_compliance(layout)
+    
+    print(f"Compliance: {report.is_compliant}")
+    print(f"Violations: {len(report.violations)}")
+    for v in report.violations:
+        print(f"  - {v}")
+    print(f"Warnings: {len(report.warnings)}")
+    for w in report.warnings:
+        print(f"  - {w}")
+    print(f"Checks passed: {len(report.checks_passed)}")
+    for c in report.checks_passed:
+        print(f"  ✓ {c}")

src/api/__init__.py

@@ -0,0 +1 @@
+"""API package"""

src/api/main.py

@@ -0,0 +1,182 @@
+"""
+FastAPI Main Application - REMB Optimization Engine
+"""
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List
+import logging
+
+from config.settings import settings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    version=settings.VERSION,
+    description="AI-Powered Industrial Estate Master Planning Optimization Engine"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Pydantic models for API
+class OptimizationRequest(BaseModel):
+    """Request model for optimization"""
+    site_id: str
+    population_size: int = 100
+    n_generations: int = 200
+    n_plots: int = 20
+
+
+class OptimizationResponse(BaseModel):
+    """Response model for optimization"""
+    optimization_id: str
+    status: str
+    n_solutions: int
+    generation_time_seconds: float
+
+
+class LayoutMetricsResponse(BaseModel):
+    """Layout metrics response"""
+    layout_id: str
+    total_area_sqm: float
+    sellable_area_sqm: float
+    green_space_area_sqm: float
+    sellable_ratio: float
+    green_space_ratio: float
+    is_compliant: bool
+
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "REMB Industrial Estate Master Planning Optimization Engine",
+        "version": settings.VERSION,
+        "status": "operational"
+    }
+
+
+@app.get("/api/v1/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "version": settings.VERSION
+    }
+
+
+@app.post("/api/v1/sites/upload")
+async def upload_site_boundary(file: UploadFile = File(...)):
+    """
+    Upload site boundary file (Shapefile or DXF)
+    
+    Args:
+        file: Shapefile (.shp) or DXF file
+        
+    Returns:
+        Site ID and metadata
+    """
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="No file provided")
+    
+    # Check file extension
+    extension = file.filename.split('.')[-1].lower()
+    if f".{extension}" not in settings.ALLOWED_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File type .{extension} not allowed. Allowed: {settings.ALLOWED_EXTENSIONS}"
+        )
+    
+    # TODO: Implement actual file processing
+    site_id = "site_123"  # Placeholder
+    
+    return {
+        "site_id": site_id,
+        "filename": file.filename,
+        "status": "uploaded",
+        "message": "Site boundary uploaded successfully"
+    }
+
+
+@app.post("/api/v1/sites/{site_id}/optimize", response_model=OptimizationResponse)
+async def optimize_site(site_id: str, request: OptimizationRequest):
+    """
+    Run optimization for a site
+    
+    Args:
+        site_id: Site identifier
+        request: Optimization parameters
+        
+    Returns:
+        Optimization results with Pareto front
+    """
+    logger.info(f"Starting optimization for site {site_id}")
+    
+    # TODO: Implement actual optimization
+    # This would call NSGA2Optimizer and return results
+    
+    return OptimizationResponse(
+        optimization_id="opt_123",
+        status="completed",
+        n_solutions=8,
+        generation_time_seconds=120.5
+    )
+
+
+@app.get("/api/v1/layouts/{layout_id}/metrics", response_model=LayoutMetricsResponse)
+async def get_layout_metrics(layout_id: str):
+    """
+    Get metrics for a specific layout
+    
+    Args:
+        layout_id: Layout identifier
+        
+    Returns:
+        Layout metrics
+    """
+    # TODO: Retrieve from database
+    return LayoutMetricsResponse(
+        layout_id=layout_id,
+        total_area_sqm=250000.0,
+        sellable_area_sqm=162500.0,
+        green_space_area_sqm=37500.0,
+        sellable_ratio=0.65,
+        green_space_ratio=0.15,
+        is_compliant=True
+    )
+
+
+@app.get("/api/v1/layouts/{layout_id}/export")
+async def export_layout_dxf(layout_id: str):
+    """
+    Export layout as DXF file
+    
+    Args:
+        layout_id: Layout identifier
+        
+    Returns:
+        DXF file download
+    """
+    # TODO: Implement DXF export
+    return {
+        "layout_id": layout_id,
+        "status": "exported",
+        "download_url": f"/downloads/{layout_id}.dxf"
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

src/api/mvp_api.py

@@ -0,0 +1,677 @@
+"""
+AIOptimize™ MVP API
+FastAPI backend for industrial estate planning optimization
+Per MVP-24h.md specification
+"""
+import os
+import io
+import json
+import zipfile
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel
+from shapely.geometry import Polygon, shape
+
+# Import services
+from src.services.session_manager import session_manager
+from src.services.gemini_service import gemini_service
+from src.algorithms.ga_optimizer import SimpleGAOptimizer
+from src.export.dxf_exporter import DXFExporter
+from src.models.domain import Layout, Plot, PlotType, SiteBoundary, LayoutMetrics
+
+# Sample data
+SAMPLE_BOUNDARY = {
+    "type": "Feature",
+    "geometry": {
+        "type": "Polygon",
+        "coordinates": [[
+            [0, 0], [500, 0], [500, 400], [0, 400], [0, 0]
+        ]]
+    },
+    "properties": {"name": "Sample Industrial Site"}
+}
+
+
+# === Pydantic Models ===
+
+class UploadResponse(BaseModel):
+    session_id: str
+    boundary: Dict[str, Any]
+    metadata: Dict[str, Any]
+
+
+class GenerateRequest(BaseModel):
+    session_id: str
+    target_plots: int = 8
+    setback: float = 50.0
+
+
+class ChatRequest(BaseModel):
+    session_id: str
+    message: str
+
+
+class ChatResponse(BaseModel):
+    message: str
+    model: str
+
+
+class ExportRequest(BaseModel):
+    session_id: str
+    option_id: int
+
+
+class HealthResponse(BaseModel):
+    status: str
+    version: str
+    gemini_available: bool
+
+
+# === FastAPI App ===
+
+app = FastAPI(
+    title="AIOptimize™ API",
+    description="AI-Powered Industrial Estate Planning Engine",
+    version="1.0.0"
+)
+
+# CORS for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allow all for development
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize optimizer and exporter
+ga_optimizer = SimpleGAOptimizer()
+dxf_exporter = DXFExporter()
+
+
+# === API Endpoints ===
+
+@app.get("/api/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return HealthResponse(
+        status="healthy",
+        version="1.0.0",
+        gemini_available=gemini_service.is_available
+    )
+
+
+@app.get("/api/sample-data")
+async def get_sample_data():
+    """Get sample GeoJSON boundary data"""
+    return SAMPLE_BOUNDARY
+
+
+@app.post("/api/upload-boundary", response_model=UploadResponse)
+async def upload_boundary(file: UploadFile = File(None), geojson: str = Form(None)):
+    """
+    Upload site boundary (GeoJSON)
+    
+    Accepts either file upload or JSON string
+    """
+    try:
+        # Get GeoJSON data
+        if file and file.filename:
+            content = await file.read()
+            geojson_data = json.loads(content)
+        elif geojson:
+            geojson_data = json.loads(geojson)
+        else:
+            raise HTTPException(400, "No boundary data provided")
+        
+        # Extract coordinates from GeoJSON
+        if geojson_data.get("type") == "Feature":
+            geometry = geojson_data.get("geometry", {})
+        elif geojson_data.get("type") == "FeatureCollection":
+            features = geojson_data.get("features", [])
+            if features:
+                geometry = features[0].get("geometry", {})
+            else:
+                raise HTTPException(400, "No features in FeatureCollection")
+        elif geojson_data.get("type") == "Polygon":
+            geometry = geojson_data
+        else:
+            raise HTTPException(400, "Invalid GeoJSON format")
+        
+        # Get coordinates
+        coords = geometry.get("coordinates", [[]])[0]
+        if not coords:
+            raise HTTPException(400, "No coordinates found")
+        
+        # Create Shapely polygon and validate
+        polygon = Polygon(coords)
+        if not polygon.is_valid:
+            polygon = polygon.buffer(0)
+        
+        # Calculate metadata
+        metadata = {
+            "area": polygon.area,
+            "perimeter": polygon.length,
+            "bounds": list(polygon.bounds),
+            "centroid": [polygon.centroid.x, polygon.centroid.y]
+        }
+        
+        # Create session and store data
+        session = session_manager.create_session()
+        session_manager.set_boundary(
+            session.id,
+            boundary=geojson_data,
+            coords=coords,
+            metadata=metadata
+        )
+        
+        return UploadResponse(
+            session_id=session.id,
+            boundary=geojson_data,
+            metadata=metadata
+        )
+        
+    except json.JSONDecodeError as e:
+        raise HTTPException(400, f"Invalid JSON format: {str(e)}")
+    except HTTPException:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(500, f"Error processing boundary: {str(e)}")
+
+
+# Alternative JSON endpoint for easier frontend integration
+class UploadBoundaryRequest(BaseModel):
+    geojson: Dict[str, Any]
+
+
+@app.post("/api/upload-boundary-json", response_model=UploadResponse)
+async def upload_boundary_json(request: UploadBoundaryRequest):
+    """Upload site boundary via JSON body"""
+    try:
+        geojson_data = request.geojson
+        
+        # Extract coordinates from GeoJSON
+        if geojson_data.get("type") == "Feature":
+            geometry = geojson_data.get("geometry", {})
+        elif geojson_data.get("type") == "FeatureCollection":
+            features = geojson_data.get("features", [])
+            if features:
+                geometry = features[0].get("geometry", {})
+            else:
+                raise HTTPException(400, "No features in FeatureCollection")
+        elif geojson_data.get("type") == "Polygon":
+            geometry = geojson_data
+        else:
+            raise HTTPException(400, "Invalid GeoJSON format")
+        
+        coords = geometry.get("coordinates", [[]])[0]
+        if not coords:
+            raise HTTPException(400, "No coordinates found")
+        
+        polygon = Polygon(coords)
+        if not polygon.is_valid:
+            polygon = polygon.buffer(0)
+        
+        metadata = {
+            "area": polygon.area,
+            "perimeter": polygon.length,
+            "bounds": list(polygon.bounds),
+            "centroid": [polygon.centroid.x, polygon.centroid.y]
+        }
+        
+        session = session_manager.create_session()
+        session_manager.set_boundary(
+            session.id,
+            boundary=geojson_data,
+            coords=coords,
+            metadata=metadata
+        )
+        
+        return UploadResponse(
+            session_id=session.id,
+            boundary=geojson_data,
+            metadata=metadata
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(500, f"Error: {str(e)}")
+
+
+@app.post("/api/upload-dxf", response_model=UploadResponse)
+async def upload_dxf(file: UploadFile = File(...)):
+    """
+    Upload site boundary from DXF file
+    
+    Parses LWPOLYLINE entities to extract site boundary polygon
+    """
+    import ezdxf
+    import tempfile
+    
+    if not file.filename or not file.filename.lower().endswith('.dxf'):
+        raise HTTPException(400, "Please upload a valid .dxf file")
+    
+    try:
+        # Save to temp file for ezdxf to read
+        content = await file.read()
+        with tempfile.NamedTemporaryFile(suffix='.dxf', delete=False) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+        
+        # Parse DXF
+        doc = ezdxf.readfile(tmp_path)
+        msp = doc.modelspace()
+        
+        # Find closed polylines
+        polygons = []
+        for entity in msp:
+            if entity.dxftype() == 'LWPOLYLINE':
+                if entity.closed:
+                    points = list(entity.get_points())
+                    if len(points) >= 3:
+                        coords = [(p[0], p[1]) for p in points]
+                        coords.append(coords[0])  # Close polygon
+                        poly = Polygon(coords)
+                        if poly.is_valid:
+                            polygons.append((poly, coords))
+            elif entity.dxftype() == 'POLYLINE':
+                if entity.is_closed:
+                    points = list(entity.points())
+                    if len(points) >= 3:
+                        coords = [(p[0], p[1]) for p in points]
+                        coords.append(coords[0])
+                        poly = Polygon(coords)
+                        if poly.is_valid:
+                            polygons.append((poly, coords))
+        
+        # Clean up temp file
+        os.unlink(tmp_path)
+        
+        if not polygons:
+            raise HTTPException(400, "No closed polygons found in DXF file")
+        
+        # Get largest polygon as site boundary
+        polygon, coords = max(polygons, key=lambda x: x[0].area)
+        
+        # Create GeoJSON boundary
+        geojson_data = {
+            "type": "Feature",
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": [coords]
+            },
+            "properties": {"source": file.filename}
+        }
+        
+        # Calculate metadata
+        metadata = {
+            "area": polygon.area,
+            "perimeter": polygon.length,
+            "bounds": list(polygon.bounds),
+            "centroid": [polygon.centroid.x, polygon.centroid.y],
+            "dxf_source": file.filename
+        }
+        
+        # Create session
+        session = session_manager.create_session()
+        session_manager.set_boundary(
+            session.id,
+            boundary=geojson_data,
+            coords=coords,
+            metadata=metadata
+        )
+        
+        print(f"[DXF] Parsed {file.filename}: {len(coords)-1} vertices, area={polygon.area:.0f}m²")
+        
+        return UploadResponse(
+            session_id=session.id,
+            boundary=geojson_data,
+            metadata=metadata
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(500, f"DXF parsing error: {str(e)}")
+
+
+@app.post("/api/generate-layouts")
+async def generate_layouts(request: GenerateRequest):
+    """
+    Generate optimized layout options using Genetic Algorithm
+    
+    Returns 3 diverse layout options:
+    1. Maximum Profit
+    2. Balanced
+    3. Premium
+    """
+    # Get session
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    
+    if not session.boundary_coords:
+        raise HTTPException(400, "No boundary uploaded for this session")
+    
+    try:
+        # Configure and run optimizer
+        optimizer = SimpleGAOptimizer(
+            setback=request.setback,
+            target_plots=request.target_plots
+        )
+        
+        options = optimizer.optimize(session.boundary_coords)
+        
+        # Store in session
+        session_manager.set_layouts(request.session_id, options)
+        
+        return {
+            "session_id": request.session_id,
+            "options": options,
+            "count": len(options)
+        }
+        
+    except Exception as e:
+        raise HTTPException(500, f"Optimization failed: {str(e)}")
+
+
+@app.post("/api/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """
+    Chat with AI about layout options
+    
+    Uses Gemini Flash 2.0 if available, otherwise falls back to hardcoded responses
+    """
+    # Get session
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    
+    # Add user message to history
+    session_manager.add_chat_message(request.session_id, "user", request.message)
+    
+    # Generate response
+    response = gemini_service.chat(
+        message=request.message,
+        layouts=session.layouts,
+        boundary_metadata=session.metadata
+    )
+    
+    # Add assistant message to history
+    session_manager.add_chat_message(
+        request.session_id, 
+        "assistant", 
+        response["message"],
+        response["model"]
+    )
+    
+    return ChatResponse(**response)
+
+
+@app.post("/api/export-dxf")
+async def export_dxf(request: ExportRequest):
+    """
+    Export single layout option to DXF
+    
+    Returns DXF file as download
+    """
+    # Get session
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    
+    if not session.layouts:
+        raise HTTPException(400, "No layouts generated")
+    
+    # Find requested option
+    option = None
+    for layout in session.layouts:
+        if layout.get("id") == request.option_id:
+            option = layout
+            break
+    
+    if not option:
+        raise HTTPException(404, f"Option {request.option_id} not found")
+    
+    try:
+        # Create Layout object for exporter
+        layout_obj = _create_layout_from_option(option, session)
+        
+        # Generate DXF to bytes
+        dxf_bytes = _export_layout_to_bytes(layout_obj, option)
+        
+        # Create filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"option_{request.option_id}_{timestamp}.dxf"
+        
+        return StreamingResponse(
+            io.BytesIO(dxf_bytes),
+            media_type="application/x-autocad-dxf",
+            headers={"Content-Disposition": f"attachment; filename={filename}"}
+        )
+        
+    except Exception as e:
+        raise HTTPException(500, f"Export failed: {str(e)}")
+
+
+@app.post("/api/export-all-dxf")
+async def export_all_dxf(session_id: str = Form(...)):
+    """
+    Export all layout options as ZIP file
+    
+    Returns ZIP containing 3 DXF files
+    """
+    # Get session
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    
+    if not session.layouts:
+        raise HTTPException(400, "No layouts generated")
+    
+    try:
+        # Create ZIP in memory
+        zip_buffer = io.BytesIO()
+        
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for option in session.layouts:
+                # Create Layout object
+                layout_obj = _create_layout_from_option(option, session)
+                
+                # Generate DXF
+                dxf_bytes = _export_layout_to_bytes(layout_obj, option)
+                
+                # Add to ZIP
+                filename = f"option_{option.get('id', 0)}_{option.get('name', 'layout').replace(' ', '_')}.dxf"
+                zf.writestr(filename, dxf_bytes)
+        
+        zip_buffer.seek(0)
+        
+        # Create filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"layouts_{timestamp}.zip"
+        
+        return StreamingResponse(
+            zip_buffer,
+            media_type="application/zip",
+            headers={"Content-Disposition": f"attachment; filename={filename}"}
+        )
+        
+    except Exception as e:
+        raise HTTPException(500, f"Export failed: {str(e)}")
+
+
+@app.get("/api/session/{session_id}")
+async def get_session(session_id: str):
+    """Get session info"""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    
+    return session.to_dict()
+
+
+# === Helper Functions ===
+
+def _create_layout_from_option(option: Dict, session) -> Layout:
+    """Convert GA option to Layout object for DXF export"""
+    from shapely.geometry import box, Polygon
+    
+    # Create site boundary
+    boundary_poly = Polygon(session.boundary_coords)
+    site = SiteBoundary(
+        geometry=boundary_poly,
+        area_sqm=boundary_poly.area
+    )
+    site.buildable_area_sqm = boundary_poly.buffer(-50).area
+    
+    # Create layout
+    layout = Layout(site_boundary=site)
+    
+    # Add plots
+    plots = []
+    for i, plot_data in enumerate(option.get("plots", [])):
+        coords = plot_data.get("coords", [])
+        if coords:
+            plot_geom = Polygon(coords)
+        else:
+            plot_geom = box(
+                plot_data["x"],
+                plot_data["y"],
+                plot_data["x"] + plot_data["width"],
+                plot_data["y"] + plot_data["height"]
+            )
+        
+        plot = Plot(
+            id=f"P{i+1}",
+            geometry=plot_geom,
+            area_sqm=plot_data.get("area", plot_geom.area),
+            type=PlotType.INDUSTRIAL,
+            width_m=plot_data.get("width", 50),
+            depth_m=plot_data.get("height", 50)
+        )
+        plots.append(plot)
+    
+    layout.plots = plots
+    
+    # Set metrics
+    metrics = option.get("metrics", {})
+    layout.metrics = LayoutMetrics(
+        total_area_sqm=site.area_sqm,
+        sellable_area_sqm=metrics.get("total_area", 0),
+        green_space_area_sqm=0,
+        road_area_sqm=0,
+        num_plots=metrics.get("total_plots", len(plots)),
+        is_compliant=True
+    )
+    layout.metrics.sellable_ratio = layout.metrics.sellable_area_sqm / layout.metrics.total_area_sqm if layout.metrics.total_area_sqm > 0 else 0
+    
+    return layout
+
+
+def _export_layout_to_bytes(layout: Layout, option: Dict) -> bytes:
+    """Export layout to DXF bytes"""
+    import ezdxf
+    from ezdxf.enums import TextEntityAlignment
+    
+    # Create DXF document
+    doc = ezdxf.new(dxfversion="R2010")
+    msp = doc.modelspace()
+    
+    # Setup layers
+    layers = {
+        'BOUNDARY': {'color': 7},      # White
+        'SETBACK': {'color': 1},       # Red
+        'PLOTS': {'color': 5},         # Blue
+        'LABELS': {'color': 7},        # White
+        'ANNOTATIONS': {'color': 2},   # Yellow
+        'TITLEBLOCK': {'color': 7}     # White
+    }
+    
+    for name, props in layers.items():
+        doc.layers.add(name, color=props['color'])
+    
+    # Draw boundary
+    if layout.site_boundary and layout.site_boundary.geometry:
+        coords = list(layout.site_boundary.geometry.exterior.coords)
+        msp.add_lwpolyline(coords, dxfattribs={'layer': 'BOUNDARY', 'closed': True})
+        
+        # Draw setback zone
+        setback = layout.site_boundary.geometry.buffer(-50)
+        if not setback.is_empty:
+            setback_coords = list(setback.exterior.coords)
+            msp.add_lwpolyline(setback_coords, dxfattribs={'layer': 'SETBACK', 'closed': True})
+    
+    # Draw plots
+    for plot in layout.plots:
+        if plot.geometry:
+            coords = list(plot.geometry.exterior.coords)
+            msp.add_lwpolyline(coords, dxfattribs={'layer': 'PLOTS', 'closed': True})
+            
+            # Add label
+            centroid = plot.geometry.centroid
+            msp.add_text(
+                plot.id,
+                dxfattribs={
+                    'layer': 'LABELS',
+                    'height': 5,
+                    'insert': (centroid.x, centroid.y)
+                }
+            )
+            
+            # Add area annotation
+            msp.add_text(
+                f"{plot.area_sqm:.0f}m²",
+                dxfattribs={
+                    'layer': 'ANNOTATIONS',
+                    'height': 3,
+                    'insert': (centroid.x, centroid.y - 8)
+                }
+            )
+    
+    # Add title block
+    if layout.site_boundary:
+        bounds = layout.site_boundary.geometry.bounds
+        minx, miny = bounds[0], bounds[1]
+        
+        title_lines = [
+            f"AIOptimize™ - {option.get('name', 'Layout')}",
+            f"Plots: {option.get('metrics', {}).get('total_plots', 0)}",
+            f"Total Area: {option.get('metrics', {}).get('total_area', 0):.0f} m²",
+            f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        ]
+        
+        y = miny - 20
+        for line in title_lines:
+            msp.add_text(
+                line,
+                dxfattribs={
+                    'layer': 'TITLEBLOCK',
+                    'height': 4,
+                    'insert': (minx, y)
+                }
+            )
+            y -= 8
+    
+    # Save to bytes
+    stream = io.StringIO()
+    doc.write(stream)
+    return stream.getvalue().encode('utf-8')
+
+
+# Run with: uvicorn src.api.mvp_api:app --reload --port 8000
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

src/core/__init__.py

@@ -0,0 +1,2 @@
+"""Core package - Orchestrator and central coordination"""
+from src.core.orchestrator import CoreOrchestrator, OrchestrationResult, OrchestrationStatus

src/core/orchestrator.py

@@ -0,0 +1,662 @@
+"""
+Core Orchestrator - The Brain/Nhạc trưởng
+Coordinates between LLM understanding and CP Module execution
+Following the "Handshake Loop" pattern from Core_document.md
+"""
+import json
+from typing import Dict, Any, Optional, List, Tuple
+from dataclasses import dataclass, field
+from enum import Enum
+import logging
+from pathlib import Path
+
+from src.models.domain import Layout, SiteBoundary, Plot, ParetoFront, ComplianceReport
+from src.algorithms.nsga2_optimizer import NSGA2Optimizer
+from src.algorithms.milp_solver import MILPSolver, MILPResult
+from src.algorithms.regulation_checker import RegulationChecker
+from src.geometry.site_processor import SiteProcessor
+from src.geometry.road_network import RoadNetworkGenerator
+from src.geometry.plot_generator import PlotGenerator
+from src.export.dxf_exporter import DXFExporter
+
+logger = logging.getLogger(__name__)
+
+
+class OrchestrationStatus(str, Enum):
+    """Status of orchestration step"""
+    SUCCESS = "success"
+    FAILURE = "failure"
+    CONFLICT = "conflict"
+    PENDING = "pending"
+
+
+@dataclass
+class OrchestrationResult:
+    """Result from orchestration step"""
+    status: OrchestrationStatus
+    message: str
+    data: Dict[str, Any] = field(default_factory=dict)
+    suggestions: List[str] = field(default_factory=list)  # For conflict resolution
+    
+    def to_json(self) -> str:
+        """Convert to JSON for LLM interpretation"""
+        return json.dumps({
+            'status': self.status.value,
+            'message': self.message,
+            'data': self.data,
+            'suggestions': self.suggestions
+        }, indent=2, default=str)
+
+
+class CoreOrchestrator:
+    """
+    Core Orchestrator - The central coordinator
+    
+    Implements the "Handshake Loop" pattern:
+    1. Dịch (Translation): Convert natural language to technical parameters
+    2. Giải (Execution): Run CP Module algorithms
+    3. Hiểu (Interpretation): Evaluate results against requirements
+    4. Quyết định (Reasoning & Action): Report success or propose alternatives
+    
+    Key principle: LLM handles semantics, CP handles math
+    - All numbers come from CP (no hallucination)
+    - LLM provides flexibility in input/output
+    """
+    
+    def __init__(self, regulations_path: str = "config/regulations.yaml"):
+        """
+        Initialize orchestrator with all modules
+        
+        Args:
+            regulations_path: Path to regulations YAML
+        """
+        self.regulations_path = regulations_path
+        
+        # Initialize all modules
+        self.site_processor = SiteProcessor(regulations_path)
+        self.road_generator = RoadNetworkGenerator(regulations_path)
+        self.plot_generator = PlotGenerator(regulations_path)
+        self.nsga2_optimizer = NSGA2Optimizer(regulations_path)
+        self.milp_solver = MILPSolver()
+        self.regulation_checker = RegulationChecker(regulations_path)
+        self.dxf_exporter = DXFExporter()
+        
+        self.logger = logging.getLogger(__name__)
+        
+        # Current session state
+        self.current_site: Optional[SiteBoundary] = None
+        self.current_layouts: List[Layout] = []
+        self.current_pareto: Optional[ParetoFront] = None
+    
+    # =========================================================================
+    # STAGE 1: Digital Twin Initialization (Dịch + Giải)
+    # =========================================================================
+    
+    def initialize_site(
+        self,
+        source: str,
+        source_type: str = "coordinates"
+    ) -> OrchestrationResult:
+        """
+        Initialize site from various sources
+        
+        Args:
+            source: File path or coordinate string
+            source_type: 'shapefile', 'geojson', 'dxf', 'coordinates'
+            
+        Returns:
+            OrchestrationResult
+        """
+        self.logger.info(f"Initializing site from {source_type}")
+        
+        try:
+            # Dịch (Translation): Parse input based on type
+            if source_type == "shapefile":
+                self.current_site = self.site_processor.import_from_shapefile(source)
+            elif source_type == "geojson":
+                self.current_site = self.site_processor.import_from_geojson(source)
+            elif source_type == "dxf":
+                self.current_site = self.site_processor.import_from_dxf(source)
+            elif source_type == "coordinates":
+                # Parse coordinates from string or list
+                if isinstance(source, str):
+                    coords = json.loads(source)
+                else:
+                    coords = source
+                self.current_site = self.site_processor.import_from_coordinates(coords)
+            else:
+                return OrchestrationResult(
+                    status=OrchestrationStatus.FAILURE,
+                    message=f"Unknown source type: {source_type}"
+                )
+            
+            # Giải (Execution): Site processor has calculated buildable area
+            
+            # Hiểu (Interpretation): Check if site is valid
+            if self.current_site.buildable_area_sqm <= 0:
+                return OrchestrationResult(
+                    status=OrchestrationStatus.CONFLICT,
+                    message="Site too small after applying setbacks",
+                    suggestions=[
+                        "Reduce boundary setback requirement",
+                        "Choose a larger site",
+                        "Apply for variance permit"
+                    ]
+                )
+            
+            # Quyết định: Success
+            return OrchestrationResult(
+                status=OrchestrationStatus.SUCCESS,
+                message="Site initialized successfully",
+                data={
+                    'site_id': self.current_site.id,
+                    'total_area_sqm': self.current_site.area_sqm,
+                    'buildable_area_sqm': self.current_site.buildable_area_sqm,
+                    'buildable_ratio': self.current_site.buildable_area_sqm / self.current_site.area_sqm,
+                    'num_constraints': len(self.current_site.constraints)
+                }
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Site initialization failed: {e}")
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message=f"Failed to initialize site: {str(e)}"
+            )
+    
+    # =========================================================================
+    # STAGE 2: Infrastructure Skeleton (Dịch + Giải)
+    # =========================================================================
+    
+    def generate_road_network(
+        self,
+        pattern: str = "grid",
+        primary_spacing: float = 200,
+        secondary_spacing: float = 100
+    ) -> OrchestrationResult:
+        """
+        Generate road network
+        
+        Args:
+            pattern: 'grid' or 'spine'
+            primary_spacing: Primary road spacing
+            secondary_spacing: Secondary road spacing
+            
+        Returns:
+            OrchestrationResult
+        """
+        if not self.current_site:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message="No site initialized. Call initialize_site first."
+            )
+        
+        self.logger.info(f"Generating {pattern} road network")
+        
+        try:
+            # Giải (Execution): Generate road network
+            if pattern == "spine":
+                road_network = self.road_generator.generate_spine_network(self.current_site)
+            else:
+                road_network = self.road_generator.generate_grid_network(
+                    self.current_site,
+                    primary_spacing=primary_spacing,
+                    secondary_spacing=secondary_spacing
+                )
+            
+            # Check for dead zones
+            dead_zones = self.road_generator.identify_dead_zones(
+                self.current_site, road_network
+            )
+            
+            # Hiểu (Interpretation)
+            if dead_zones:
+                dead_area = sum(z.area for z in dead_zones)
+                if dead_area > self.current_site.buildable_area_sqm * 0.1:
+                    return OrchestrationResult(
+                        status=OrchestrationStatus.CONFLICT,
+                        message=f"Road network leaves {len(dead_zones)} dead zones ({dead_area:.0f}m²)",
+                        data={'road_network': road_network, 'dead_zones': len(dead_zones)},
+                        suggestions=[
+                            f"Try pattern='grid' with smaller spacing",
+                            f"Add more secondary roads",
+                            f"Accept dead zones as green space"
+                        ]
+                    )
+            
+            # Store road network in site for later use
+            self._current_road_network = road_network
+            
+            return OrchestrationResult(
+                status=OrchestrationStatus.SUCCESS,
+                message="Road network generated successfully",
+                data={
+                    'total_length_m': road_network.total_length_m,
+                    'total_area_sqm': road_network.total_area_sqm,
+                    'dead_zones': len(dead_zones) if dead_zones else 0,
+                    'pattern': pattern
+                }
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Road network generation failed: {e}")
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message=f"Failed to generate road network: {str(e)}"
+            )
+    
+    # =========================================================================
+    # STAGE 3: Constraint Mapping (Dịch + Giải)
+    # =========================================================================
+    
+    def add_constraint(
+        self,
+        constraint_type: str,
+        description: str,
+        geometry: Any,
+        buffer_m: float = 0
+    ) -> OrchestrationResult:
+        """
+        Add a constraint to the site
+        
+        Natural language examples that LLM would translate:
+        - "Tránh kho xăng 200m" -> constraint_type="hazard", buffer_m=200
+        - "Cách sông 100m" -> constraint_type="waterway", buffer_m=100
+        
+        Args:
+            constraint_type: Type of constraint
+            description: Human-readable description
+            geometry: Constraint geometry (coordinates or polygon)
+            buffer_m: Buffer distance in meters
+            
+        Returns:
+            OrchestrationResult
+        """
+        if not self.current_site:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message="No site initialized"
+            )
+        
+        try:
+            from src.models.domain import ConstraintType
+            
+            # Dịch (Translation): Map string to enum
+            type_map = {
+                'setback': ConstraintType.SETBACK,
+                'fire_safety': ConstraintType.FIRE_SAFETY,
+                'waterway': ConstraintType.WATERWAY,
+                'hazard': ConstraintType.HAZARD_ZONE,
+                'no_build': ConstraintType.NO_BUILD
+            }
+            
+            constraint_enum = type_map.get(constraint_type.lower(), ConstraintType.NO_BUILD)
+            
+            # Giải (Execution)
+            constraint = self.site_processor.add_constraint(
+                self.current_site,
+                constraint_enum,
+                geometry,
+                buffer_distance=buffer_m,
+                description=description
+            )
+            
+            # Hiểu (Interpretation)
+            if self.current_site.buildable_area_sqm <= 0:
+                return OrchestrationResult(
+                    status=OrchestrationStatus.CONFLICT,
+                    message="Site no longer has buildable area after constraint",
+                    suggestions=[
+                        "Reduce buffer distance",
+                        "Move constraint location",
+                        "Request exemption"
+                    ]
+                )
+            
+            return OrchestrationResult(
+                status=OrchestrationStatus.SUCCESS,
+                message=f"Constraint added: {description}",
+                data={
+                    'constraint_type': constraint_type,
+                    'buffer_m': buffer_m,
+                    'remaining_buildable_sqm': self.current_site.buildable_area_sqm
+                }
+            )
+            
+        except Exception as e:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message=f"Failed to add constraint: {str(e)}"
+            )
+    
+    # =========================================================================
+    # STAGE 4: Automated Optimization (Hybrid AI: GA + MILP)
+    # =========================================================================
+    
+    def run_optimization(
+        self,
+        population_size: int = 100,
+        n_generations: int = 200,
+        n_plots: int = 20
+    ) -> OrchestrationResult:
+        """
+        Run full optimization pipeline (NSGA-II + MILP + Compliance)
+        
+        This is the core of the "Handshake Loop" - multiple iterations
+        between GA exploration and MILP validation.
+        
+        Args:
+            population_size: NSGA-II population size
+            n_generations: Number of GA generations
+            n_plots: Target number of plots
+            
+        Returns:
+            OrchestrationResult with Pareto front
+        """
+        if not self.current_site:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message="No site initialized"
+            )
+        
+        self.logger.info("Starting optimization pipeline")
+        
+        try:
+            # STEP 1: NSGA-II Exploration (Giải)
+            self.logger.info("Step 1: NSGA-II multi-objective optimization")
+            pareto_front = self.nsga2_optimizer.optimize(
+                site_boundary=self.current_site,
+                population_size=population_size,
+                n_generations=n_generations,
+                n_plots=n_plots
+            )
+            
+            if not pareto_front.layouts:
+                return OrchestrationResult(
+                    status=OrchestrationStatus.FAILURE,
+                    message="NSGA-II failed to generate valid layouts",
+                    suggestions=[
+                        "Reduce number of plots",
+                        "Relax constraints",
+                        "Check site configuration"
+                    ]
+                )
+            
+            # STEP 2: MILP Validation for each layout (Giải)
+            self.logger.info("Step 2: MILP validation")
+            validated_layouts = []
+            
+            for layout in pareto_front.layouts:
+                refined_layout, milp_result = self.milp_solver.validate_and_refine(layout)
+                
+                if milp_result.is_success():
+                    validated_layouts.append(refined_layout)
+            
+            if not validated_layouts:
+                return OrchestrationResult(
+                    status=OrchestrationStatus.CONFLICT,
+                    message="No layouts passed MILP validation",
+                    data={'original_count': len(pareto_front.layouts)},
+                    suggestions=[
+                        "Reduce plot density",
+                        "Increase road network",
+                        "Review constraint compatibility"
+                    ]
+                )
+            
+            # STEP 3: Regulatory Compliance Check (Giải)
+            self.logger.info("Step 3: Regulatory compliance check")
+            compliant_layouts = []
+            violations_summary = []
+            
+            for layout in validated_layouts:
+                report = self.regulation_checker.validate_compliance(layout)
+                layout.metrics.is_compliant = report.is_compliant
+                layout.metrics.compliance_violations = report.violations
+                
+                if report.is_compliant:
+                    compliant_layouts.append(layout)
+                else:
+                    violations_summary.extend(report.violations[:2])  # Top 2 violations
+            
+            # Hiểu (Interpretation) + Quyết định (Reasoning)
+            if not compliant_layouts:
+                return OrchestrationResult(
+                    status=OrchestrationStatus.CONFLICT,
+                    message="No layouts meet regulatory compliance",
+                    data={
+                        'validated_count': len(validated_layouts),
+                        'sample_violations': violations_summary[:5]
+                    },
+                    suggestions=[
+                        "Increase green space ratio",
+                        "Review boundary setbacks",
+                        "Reduce plot density"
+                    ]
+                )
+            
+            # Success - store Pareto front
+            self.current_pareto = ParetoFront(
+                layouts=compliant_layouts,
+                generation_time_seconds=pareto_front.generation_time_seconds
+            )
+            self.current_layouts = compliant_layouts
+            
+            # Generate summary
+            max_sellable = self.current_pareto.get_max_sellable_layout()
+            max_green = self.current_pareto.get_max_green_layout()
+            balanced = self.current_pareto.get_balanced_layout()
+            
+            return OrchestrationResult(
+                status=OrchestrationStatus.SUCCESS,
+                message=f"Generated {len(compliant_layouts)} compliant layouts",
+                data={
+                    'num_layouts': len(compliant_layouts),
+                    'generation_time_seconds': pareto_front.generation_time_seconds,
+                    'max_sellable_area': max_sellable.metrics.sellable_area_sqm if max_sellable else 0,
+                    'max_green_ratio': max_green.metrics.green_space_ratio if max_green else 0,
+                    'balanced_sellable': balanced.metrics.sellable_area_sqm if balanced else 0,
+                    'scenarios': [
+                        {
+                            'name': 'Max Sellable',
+                            'id': max_sellable.id if max_sellable else None,
+                            'sellable_sqm': max_sellable.metrics.sellable_area_sqm if max_sellable else 0
+                        },
+                        {
+                            'name': 'Max Green',
+                            'id': max_green.id if max_green else None,
+                            'green_ratio': max_green.metrics.green_space_ratio if max_green else 0
+                        },
+                        {
+                            'name': 'Balanced',
+                            'id': balanced.id if balanced else None
+                        }
+                    ]
+                }
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Optimization failed: {e}")
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message=f"Optimization pipeline failed: {str(e)}"
+            )
+    
+    # =========================================================================
+    # STAGE 5: Engineering Delivery (Giải + Output)
+    # =========================================================================
+    
+    def export_layout(
+        self,
+        layout_id: str,
+        output_path: str,
+        format: str = "dxf"
+    ) -> OrchestrationResult:
+        """
+        Export a specific layout to file
+        
+        Args:
+            layout_id: Layout ID to export
+            output_path: Output file path
+            format: Export format ('dxf')
+            
+        Returns:
+            OrchestrationResult
+        """
+        # Find layout
+        layout = None
+        for l in self.current_layouts:
+            if l.id == layout_id:
+                layout = l
+                break
+        
+        if not layout:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message=f"Layout not found: {layout_id}"
+            )
+        
+        try:
+            if format.lower() == "dxf":
+                filepath = self.dxf_exporter.export(layout, output_path)
+                return OrchestrationResult(
+                    status=OrchestrationStatus.SUCCESS,
+                    message=f"Layout exported to {filepath}",
+                    data={'filepath': filepath, 'format': 'DXF'}
+                )
+            else:
+                return OrchestrationResult(
+                    status=OrchestrationStatus.FAILURE,
+                    message=f"Unsupported format: {format}"
+                )
+                
+        except Exception as e:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message=f"Export failed: {str(e)}"
+            )
+    
+    def export_all_layouts(self, output_dir: str) -> OrchestrationResult:
+        """
+        Export all layouts in Pareto front
+        
+        Args:
+            output_dir: Output directory
+            
+        Returns:
+            OrchestrationResult
+        """
+        if not self.current_pareto:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message="No optimization results available"
+            )
+        
+        try:
+            files = self.dxf_exporter.export_pareto_front(
+                self.current_pareto,
+                output_dir,
+                prefix="layout"
+            )
+            
+            return OrchestrationResult(
+                status=OrchestrationStatus.SUCCESS,
+                message=f"Exported {len(files)} layouts",
+                data={'files': files}
+            )
+            
+        except Exception as e:
+            return OrchestrationResult(
+                status=OrchestrationStatus.FAILURE,
+                message=f"Export failed: {str(e)}"
+            )
+    
+    # =========================================================================
+    # JSON Interface for LLM Function Calling
+    # =========================================================================
+    
+    def execute_command(self, command_json: str) -> str:
+        """
+        Execute a command from LLM via JSON
+        
+        This is the standardized interface for LLM → Orchestrator communication.
+        
+        Input format:
+        {
+            "action": "initialize_site" | "generate_roads" | "add_constraint" | "optimize" | "export",
+            "parameters": {...}
+        }
+        
+        Args:
+            command_json: JSON command string
+            
+        Returns:
+            JSON response string
+        """
+        try:
+            command = json.loads(command_json)
+            action = command.get('action')
+            params = command.get('parameters', {})
+            
+            if action == 'initialize_site':
+                result = self.initialize_site(**params)
+            elif action == 'generate_roads':
+                result = self.generate_road_network(**params)
+            elif action == 'add_constraint':
+                result = self.add_constraint(**params)
+            elif action == 'optimize':
+                result = self.run_optimization(**params)
+            elif action == 'export':
+                result = self.export_layout(**params)
+            elif action == 'export_all':
+                result = self.export_all_layouts(**params)
+            else:
+                result = OrchestrationResult(
+                    status=OrchestrationStatus.FAILURE,
+                    message=f"Unknown action: {action}"
+                )
+            
+            return result.to_json()
+            
+        except json.JSONDecodeError as e:
+            return json.dumps({
+                'status': 'failure',
+                'message': f'Invalid JSON: {str(e)}'
+            })
+        except Exception as e:
+            return json.dumps({
+                'status': 'failure',
+                'message': f'Execution error: {str(e)}'
+            })
+
+
+# Example usage
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    # Initialize orchestrator
+    orchestrator = CoreOrchestrator()
+    
+    # Stage 1: Initialize site
+    coords = [(0, 0), (500, 0), (500, 500), (0, 500), (0, 0)]
+    result = orchestrator.initialize_site(coords, source_type="coordinates")
+    print(f"Site init: {result.status.value}")
+    print(result.to_json())
+    
+    # Stage 2: Generate roads
+    result = orchestrator.generate_road_network(pattern="grid", primary_spacing=150)
+    print(f"\nRoad gen: {result.status.value}")
+    
+    # Stage 4: Run optimization
+    result = orchestrator.run_optimization(
+        population_size=50,
+        n_generations=50,
+        n_plots=10
+    )
+    print(f"\nOptimization: {result.status.value}")
+    print(result.to_json())
+    
+    # Stage 5: Export
+    if result.status == OrchestrationStatus.SUCCESS:
+        result = orchestrator.export_all_layouts("output/")
+        print(f"\nExport: {result.status.value}")

src/export/__init__.py

@@ -0,0 +1,2 @@
+"""Export package"""
+from src.export.dxf_exporter import DXFExporter

src/export/dxf_exporter.py

@@ -0,0 +1,444 @@
+"""
+DXF Exporter - Engineering Delivery
+Export layouts to AutoCAD DXF format with proper layering
+"""
+import ezdxf
+from ezdxf.enums import TextEntityAlignment
+from shapely.geometry import Polygon, MultiPolygon, LineString, MultiLineString
+from typing import List, Optional, Dict, Tuple
+from pathlib import Path
+import logging
+from datetime import datetime
+
+from src.models.domain import Layout, Plot, PlotType, SiteBoundary, RoadNetwork
+
+logger = logging.getLogger(__name__)
+
+
+class DXFExporter:
+    """
+    AutoCAD DXF file exporter
+    
+    Exports industrial estate layouts with proper layering:
+    - SITE_BOUNDARY: Site boundary polygon
+    - ROADS_PRIMARY: Primary road network
+    - ROADS_SECONDARY: Secondary road network
+    - PLOTS_INDUSTRIAL: Industrial plots
+    - PLOTS_GREEN: Green space plots
+    - UTILITIES: Utility corridors
+    - ANNOTATIONS: Text annotations and dimensions
+    """
+    
+    # Layer configuration
+    LAYERS = {
+        'SITE_BOUNDARY': {'color': 7, 'linetype': 'CONTINUOUS'},  # White
+        'ROADS_PRIMARY': {'color': 1, 'linetype': 'CONTINUOUS'},  # Red
+        'ROADS_SECONDARY': {'color': 3, 'linetype': 'DASHED'},  # Green
+        'ROADS_TERTIARY': {'color': 4, 'linetype': 'DASHED'},  # Cyan
+        'PLOTS_INDUSTRIAL': {'color': 5, 'linetype': 'CONTINUOUS'},  # Blue
+        'PLOTS_GREEN': {'color': 3, 'linetype': 'CONTINUOUS'},  # Green
+        'PLOTS_UTILITY': {'color': 6, 'linetype': 'CONTINUOUS'},  # Magenta
+        'CONSTRAINTS': {'color': 1, 'linetype': 'PHANTOM'},  # Red dashed
+        'ANNOTATIONS': {'color': 7, 'linetype': 'CONTINUOUS'},  # White
+        'DIMENSIONS': {'color': 2, 'linetype': 'CONTINUOUS'},  # Yellow
+    }
+    
+    def __init__(self, version: str = "R2010"):
+        """
+        Initialize DXF exporter
+        
+        Args:
+            version: DXF version ('R12', 'R2000', 'R2004', 'R2007', 'R2010', 'R2013', 'R2018')
+        """
+        self.version = version
+        self.logger = logging.getLogger(__name__)
+    
+    def export(
+        self,
+        layout: Layout,
+        filepath: str,
+        include_annotations: bool = True,
+        include_dimensions: bool = True
+    ) -> str:
+        """
+        Export layout to DXF file
+        
+        Args:
+            layout: Layout to export
+            filepath: Output file path
+            include_annotations: Include text annotations
+            include_dimensions: Include dimensions
+            
+        Returns:
+            Path to created file
+        """
+        self.logger.info(f"Exporting layout {layout.id} to DXF: {filepath}")
+        
+        # Create new DXF document with setup=True to include standard linetypes (DASHED, PHANTOM, etc.)
+        doc = ezdxf.new(dxfversion=self.version, setup=True)
+        msp = doc.modelspace()
+        
+        # Setup layers and dimension style
+        self._setup_layers(doc)
+        self._setup_dimension_style(doc)
+        
+        # Export site boundary
+        if layout.site_boundary and layout.site_boundary.geometry:
+            self._export_site_boundary(msp, layout.site_boundary)
+        
+        # Export road network
+        if layout.road_network:
+            self._export_road_network(msp, layout.road_network)
+        
+        # Export plots
+        for plot in layout.plots:
+            self._export_plot(msp, plot)
+        
+        # Export constraints
+        if layout.site_boundary:
+            for constraint in layout.site_boundary.constraints:
+                self._export_constraint(msp, constraint)
+        
+        # Add annotations
+        if include_annotations:
+            self._add_annotations(msp, layout)
+        
+        # Add dimensions
+        if include_dimensions:
+            self._add_dimensions(msp, layout)
+        
+        # Add title block
+        self._add_title_block(msp, layout)
+        
+        # Save file with error handling for file locking
+        output_path = Path(filepath)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            doc.saveas(str(filepath))
+        except PermissionError:
+            # File is locked (e.g., open in AutoCAD)
+            self.logger.warning(f"File is locked: {filepath}, trying alternate name")
+            timestamp = datetime.now().strftime('%H%M%S')
+            alt_path = output_path.with_stem(f"{output_path.stem}_{timestamp}")
+            doc.saveas(str(alt_path))
+            self.logger.info(f"DXF exported to alternate path: {alt_path}")
+            return str(alt_path)
+        
+        self.logger.info(f"DXF exported successfully: {filepath}")
+        return str(filepath)
+    
+    def _setup_layers(self, doc):
+        """Setup DXF layers with colors and linetypes"""
+        for layer_name, config in self.LAYERS.items():
+            linetype = config.get('linetype', 'CONTINUOUS')
+            # Ensure linetype exists (setup=True should provide DASHED, PHANTOM, etc.)
+            if linetype not in doc.linetypes:
+                linetype = 'CONTINUOUS'
+            doc.layers.add(
+                layer_name,
+                color=config['color'],
+                linetype=linetype
+            )
+    
+    def _setup_dimension_style(self, doc):
+        """
+        Setup custom dimension style for stability
+        Prevents crashes from malformed default dimension styles
+        """
+        # Create custom engineering dimension style
+        if 'ENG_DIM' not in doc.dimstyles:
+            dim_style = doc.dimstyles.new('ENG_DIM')
+            dim_style.dxf.dimtxt = 2.5      # Text height
+            dim_style.dxf.dimasz = 2.5      # Arrow size
+            dim_style.dxf.dimexe = 1.5      # Extension line extension
+            dim_style.dxf.dimexo = 0.625    # Extension line offset
+            dim_style.dxf.dimgap = 0.625    # Gap from dimension line
+            dim_style.dxf.dimdec = 2        # Decimal places
+            dim_style.dxf.dimtad = 1        # Text above dimension line
+            dim_style.dxf.dimclrd = 2       # Dimension line color (yellow)
+            dim_style.dxf.dimclre = 2       # Extension line color (yellow)
+            dim_style.dxf.dimclrt = 7       # Text color (white)
+    
+    def _export_site_boundary(self, msp, site: SiteBoundary):
+        """Export site boundary polygon"""
+        if site.geometry:
+            coords = self._polygon_to_coords(site.geometry)
+            msp.add_lwpolyline(
+                coords,
+                dxfattribs={'layer': 'SITE_BOUNDARY', 'closed': True}
+            )
+    
+    def _export_road_network(self, msp, road_network: RoadNetwork):
+        """Export road network lines"""
+        # Primary roads
+        if road_network.primary_roads:
+            self._export_multilinestring(
+                msp, road_network.primary_roads, 'ROADS_PRIMARY'
+            )
+        
+        # Secondary roads
+        if road_network.secondary_roads:
+            self._export_multilinestring(
+                msp, road_network.secondary_roads, 'ROADS_SECONDARY'
+            )
+        
+        # Tertiary roads
+        if road_network.tertiary_roads:
+            self._export_multilinestring(
+                msp, road_network.tertiary_roads, 'ROADS_TERTIARY'
+            )
+    
+    def _export_multilinestring(self, msp, geometry, layer: str):
+        """Export MultiLineString or LineString to DXF"""
+        if hasattr(geometry, 'geoms'):
+            lines = geometry.geoms
+        else:
+            lines = [geometry]
+        
+        for line in lines:
+            if isinstance(line, LineString):
+                points = [(p[0], p[1]) for p in line.coords]
+                msp.add_lwpolyline(
+                    points,
+                    dxfattribs={'layer': layer}
+                )
+    
+    def _export_plot(self, msp, plot: Plot):
+        """Export a plot polygon"""
+        if not plot.geometry:
+            return
+        
+        # Determine layer based on plot type
+        layer_map = {
+            PlotType.INDUSTRIAL: 'PLOTS_INDUSTRIAL',
+            PlotType.GREEN_SPACE: 'PLOTS_GREEN',
+            PlotType.UTILITY: 'PLOTS_UTILITY',
+            PlotType.ROAD: 'ROADS_TERTIARY',
+            PlotType.BUFFER: 'CONSTRAINTS'
+        }
+        layer = layer_map.get(plot.type, 'PLOTS_INDUSTRIAL')
+        
+        # Export polygon
+        coords = self._polygon_to_coords(plot.geometry)
+        msp.add_lwpolyline(
+            coords,
+            dxfattribs={'layer': layer, 'closed': True}
+        )
+        
+        # Add plot ID label at centroid
+        centroid = plot.geometry.centroid
+        msp.add_text(
+            plot.id,
+            dxfattribs={
+                'layer': 'ANNOTATIONS',
+                'height': 2,
+                'insert': (centroid.x, centroid.y)
+            }
+        )
+    
+    def _export_constraint(self, msp, constraint):
+        """Export constraint zone"""
+        if not constraint.geometry:
+            return
+        
+        if isinstance(constraint.geometry, Polygon):
+            coords = self._polygon_to_coords(constraint.geometry)
+            msp.add_lwpolyline(
+                coords,
+                dxfattribs={'layer': 'CONSTRAINTS', 'closed': True}
+            )
+    
+    def _add_annotations(self, msp, layout: Layout):
+        """Add text annotations"""
+        # Summary annotation at top-right
+        if layout.site_boundary:
+            bounds = layout.site_boundary.geometry.bounds
+            maxx, maxy = bounds[2], bounds[3]
+            
+            # Create summary text
+            metrics = layout.metrics
+            summary_lines = [
+                f"LAYOUT SUMMARY",
+                f"----------------",
+                f"Total Area: {metrics.total_area_sqm:.0f} m²",
+                f"Sellable: {metrics.sellable_area_sqm:.0f} m² ({metrics.sellable_ratio*100:.1f}%)",
+                f"Green: {metrics.green_space_area_sqm:.0f} m² ({metrics.green_space_ratio*100:.1f}%)",
+                f"Roads: {metrics.road_area_sqm:.0f} m²",
+                f"Num Plots: {metrics.num_plots}",
+                f"Compliant: {'Yes' if metrics.is_compliant else 'No'}"
+            ]
+            
+            y_offset = maxy + 20
+            for line in summary_lines:
+                msp.add_text(
+                    line,
+                    dxfattribs={
+                        'layer': 'ANNOTATIONS',
+                        'height': 3,
+                        'insert': (maxx + 20, y_offset)
+                    }
+                )
+                y_offset -= 5
+    
+    def _add_dimensions(self, msp, layout: Layout):
+        """Add dimension annotations"""
+        if layout.site_boundary and layout.site_boundary.geometry:
+            bounds = layout.site_boundary.geometry.bounds
+            minx, miny, maxx, maxy = bounds
+            
+            # Add site dimensions using custom dimension style
+            # Width dimension
+            msp.add_linear_dim(
+                base=(minx, miny - 10),
+                p1=(minx, miny),
+                p2=(maxx, miny),
+                dimstyle='ENG_DIM',
+                dxfattribs={'layer': 'DIMENSIONS'}
+            ).render()
+            
+            # Height dimension
+            msp.add_linear_dim(
+                base=(maxx + 10, miny),
+                p1=(maxx, miny),
+                p2=(maxx, maxy),
+                angle=90,
+                dimstyle='ENG_DIM',
+                dxfattribs={'layer': 'DIMENSIONS'}
+            ).render()
+    
+    def _add_title_block(self, msp, layout: Layout):
+        """Add title block with project info"""
+        if not layout.site_boundary:
+            return
+        
+        bounds = layout.site_boundary.geometry.bounds
+        minx, miny = bounds[0], bounds[1]
+        
+        # Title block at bottom-left
+        title_lines = [
+            "INDUSTRIAL ESTATE MASTER PLAN",
+            f"Layout ID: {layout.id}",
+            f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}",
+            "REMB Optimization Engine v0.1.0",
+            "PiXerse.AI"
+        ]
+        
+        y_offset = miny - 30
+        for i, line in enumerate(title_lines):
+            msp.add_text(
+                line,
+                dxfattribs={
+                    'layer': 'ANNOTATIONS',
+                    'height': 4 if i == 0 else 2.5,
+                    'insert': (minx, y_offset)
+                }
+            )
+            y_offset -= 6
+    
+    def _polygon_to_coords(self, polygon: Polygon) -> List[Tuple[float, float]]:
+        """Convert Shapely polygon to coordinate list"""
+        return [(p[0], p[1]) for p in polygon.exterior.coords]
+    
+    def export_pareto_front(
+        self,
+        pareto_front,
+        output_dir: str,
+        prefix: str = "layout"
+    ) -> List[str]:
+        """
+        Export all layouts in a Pareto front
+        
+        Args:
+            pareto_front: ParetoFront object
+            output_dir: Output directory
+            prefix: Filename prefix
+            
+        Returns:
+            List of created file paths
+        """
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        
+        files = []
+        for i, layout in enumerate(pareto_front.layouts):
+            filename = f"{prefix}_{i:02d}_{layout.id[:8]}.dxf"
+            filepath = output_path / filename
+            self.export(layout, str(filepath))
+            files.append(str(filepath))
+        
+        return files
+
+
+# Example usage
+if __name__ == "__main__":
+    from shapely.geometry import box
+    from src.models.domain import Layout, Plot, PlotType, SiteBoundary, RoadNetwork, LayoutMetrics
+    from shapely.geometry import LineString, MultiLineString
+    
+    # Create example layout
+    site_geom = box(0, 0, 500, 500)
+    site = SiteBoundary(geometry=site_geom, area_sqm=site_geom.area)
+    site.buildable_area_sqm = site.area_sqm
+    
+    layout = Layout(site_boundary=site)
+    
+    # Add some plots
+    layout.plots = [
+        Plot(
+            id="plot_001",
+            geometry=box(60, 60, 160, 160),
+            area_sqm=10000,
+            type=PlotType.INDUSTRIAL,
+            width_m=100,
+            depth_m=100
+        ),
+        Plot(
+            id="plot_002",
+            geometry=box(200, 60, 300, 160),
+            area_sqm=10000,
+            type=PlotType.INDUSTRIAL,
+            width_m=100,
+            depth_m=100
+        ),
+        Plot(
+            id="green_001",
+            geometry=box(60, 200, 160, 300),
+            area_sqm=10000,
+            type=PlotType.GREEN_SPACE,
+            width_m=100,
+            depth_m=100
+        )
+    ]
+    
+    # Add road network
+    layout.road_network = RoadNetwork(
+        primary_roads=MultiLineString([
+            LineString([(0, 250), (500, 250)]),
+            LineString([(250, 0), (250, 500)])
+        ]),
+        total_length_m=1000
+    )
+    
+    # Calculate metrics
+    layout.metrics = LayoutMetrics(
+        total_area_sqm=250000,
+        sellable_area_sqm=20000,
+        green_space_area_sqm=10000,
+        road_area_sqm=24000,
+        sellable_ratio=0.65,
+        green_space_ratio=0.15,
+        num_plots=2,
+        is_compliant=True
+    )
+    
+    # Export
+    exporter = DXFExporter()
+    output_file = exporter.export(
+        layout,
+        "output/test_layout.dxf",
+        include_annotations=True,
+        include_dimensions=True
+    )
+    
+    print(f"Exported to: {output_file}")