chore: clean up for HF Spaces deployment

- Remove old root-level .py files (now in core/, server/ packages)
- Remove crewai from deps (optional, not in uv.lock)
- Add .env to .gitignore
- Add env var passthrough in docker-compose.yml
- Add multi-agent chat design spec

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.gitignore

@@ -4,3 +4,4 @@ output/
 .superpowers/
 .venv/
 .worktrees/
+.env

cadquery_system_prompt.py

@@ -1,151 +0,0 @@
-"""
-System prompt and few-shot examples for the CadQuery code generation LLM.
-This module defines the domain knowledge the LLM needs to produce valid,
-CNC-machinable CadQuery scripts.
-"""
-
-CADQUERY_SYSTEM_PROMPT = """\
-You are an expert CNC machinist and CAD engineer. Your job is to generate
-CadQuery Python code that creates a 3D solid model from a natural-language
-description of a mechanical part.
-
-## Rules
-1. Output ONLY valid Python code. No markdown fences, no explanations.
-2. Always `import cadquery as cq` at the top.
-3. The final result MUST be assigned to a variable called `result` and must be
-   a `cq.Workplane` object (not a raw Shape).
-4. Design for CNC machinability:
-   - Prefer prismatic geometry (boxes, cylinders, slots, pockets, holes).
-   - Add fillets >= 1mm on internal corners (tool radius constraint).
-   - Avoid undercuts that a 3-axis mill cannot reach.
-   - Avoid infinitely thin walls — minimum 1.5mm wall thickness.
-   - Chamfer sharp external edges (0.5mm default) for deburring.
-5. Use millimeters as the unit system.
-6. Keep the code concise but readable. Add a brief comment header describing
-   the part.
-7. If the description is ambiguous, make reasonable engineering assumptions
-   and note them in comments.
-8. Center the part on the origin when practical.
-
-## CadQuery Quick Reference
-- `cq.Workplane("XY")` — start a workplane
-- `.box(length, width, height)` — centered box
-- `.cylinder(height, radius)` — centered cylinder
-- `.hole(diameter)` — through hole
-- `.cboreHole(diameter, cboreDiameter, cboreDepth)` — counterbore hole
-- `.cskHole(diameter, cskDiameter, cskAngle)` — countersink hole
-- `.slot2D(length, width)` — 2D slot profile, then extrude
-- `.rect(x, y)` / `.circle(radius)` — 2D sketch primitives
-- `.extrude(distance)` — extrude sketch into solid
-- `.cut(other_solid)` — boolean subtract
-- `.union(other_solid)` — boolean add
-- `.fillet(radius)` — fillet edges
-- `.chamfer(distance)` — chamfer edges
-- `.faces(">Z")` / `.faces("<Z")` — select top/bottom faces
-- `.edges("|Z")` — select edges parallel to Z
-- `.pushPoints([(x,y), ...])` — array of features
-- `.polarArray(radius, startAngle, angle, count)` — circular pattern
-- `.workplane(offset=d)` — offset workplane
-- `.transformed(offset=(x,y,z), rotate=(rx,ry,rz))` — transformed workplane
-
-## Output Format
-Return ONLY the Python code. Nothing else.
-"""
-
-FEW_SHOT_EXAMPLES = [
-    {
-        "prompt": "A simple mounting bracket with two M5 bolt holes, 60mm wide, 40mm tall, 5mm thick",
-        "code": """\
-import cadquery as cq
-
-# Mounting bracket: 60x40x5mm plate with two M5 (5.5mm clearance) holes
-# Holes spaced 40mm apart, centered horizontally, 15mm from top
-
-result = (
-    cq.Workplane("XY")
-    .box(60, 40, 5)  # Main plate
-    .faces(">Z")
-    .workplane()
-    .pushPoints([(-20, 5), (20, 5)])  # Two hole positions
-    .hole(5.5)  # M5 clearance holes
-    .edges("|Z")
-    .fillet(2)  # Fillet vertical edges for machinability
-    .edges(">Z")
-    .chamfer(0.5)  # Chamfer top edges
-)
-"""
-    },
-    {
-        "prompt": "A cylindrical spacer, 25mm outer diameter, 10mm inner hole, 15mm tall",
-        "code": """\
-import cadquery as cq
-
-# Cylindrical spacer: OD=25mm, ID=10mm, height=15mm
-# Chamfered top and bottom edges for deburring
-
-result = (
-    cq.Workplane("XY")
-    .cylinder(15, 25 / 2)  # OD=25mm cylinder, height=15mm
-    .faces(">Z")
-    .workplane()
-    .hole(10)  # 10mm through hole
-    .edges()
-    .chamfer(0.5)  # Chamfer all edges
-)
-"""
-    },
-    {
-        "prompt": "An L-shaped bracket, 50mm on each arm, 20mm wide, 4mm thick, with a 6mm hole in each arm",
-        "code": """\
-import cadquery as cq
-
-# L-shaped bracket: two arms 50mm each, 20mm wide, 4mm thick
-# One 6mm hole centered in each arm
-# Internal corner filleted for CNC tool access
-
-# Build as a 2D profile extruded to width
-result = (
-    cq.Workplane("XZ")
-    .moveTo(0, 0)
-    .lineTo(50, 0)     # Horizontal arm
-    .lineTo(50, 4)
-    .lineTo(4, 4)
-    .lineTo(4, 50)     # Vertical arm
-    .lineTo(0, 50)
-    .close()
-    .extrude(20)        # Extrude to 20mm width
-
-    # Internal fillet for CNC machinability (min tool radius)
-    .edges("|Y").fillet(3)
-
-    # Hole in horizontal arm
-    .faces(">Z")
-    .workplane(centerOption="CenterOfBoundBox")
-    .center(25, 0)
-    .hole(6)
-
-    # Hole in vertical arm
-    .faces(">X")
-    .workplane(centerOption="CenterOfBoundBox")
-    .center(0, 25)
-    .hole(6)
-
-    # Chamfer external edges
-    .edges().chamfer(0.5)
-)
-"""
-    },
-]
-
-
-def build_messages(user_prompt: str) -> list[dict]:
-    """Build the message list for the LLM API call, including system prompt
-    and few-shot examples."""
-    messages = [{"role": "system", "content": CADQUERY_SYSTEM_PROMPT}]
-
-    for ex in FEW_SHOT_EXAMPLES:
-        messages.append({"role": "user", "content": ex["prompt"]})
-        messages.append({"role": "assistant", "content": ex["code"]})
-
-    messages.append({"role": "user", "content": user_prompt})
-    return messages

cnc_validator.py

@@ -1,224 +0,0 @@
-"""
-CNC Manufacturability Validator.
-Checks a CadQuery solid for common CNC machining issues:
-- Thin walls
-- Sharp internal corners (no fillet / too small for tool)
-- Deep narrow pockets (aspect ratio)
-- Overall size feasibility
-- Undercut detection (basic heuristic)
-"""
-
-from dataclasses import dataclass, field
-from typing import Optional
-
-import cadquery as cq
-
-
-@dataclass
-class CNCIssue:
-    severity: str  # "error", "warning", "info"
-    category: str
-    message: str
-
-
-@dataclass
-class CNCValidationResult:
-    part_name: str
-    issues: list[CNCIssue] = field(default_factory=list)
-    machinable: bool = True
-    axis_recommendation: str = "3-axis"
-
-    @property
-    def error_count(self) -> int:
-        return sum(1 for i in self.issues if i.severity == "error")
-
-    @property
-    def warning_count(self) -> int:
-        return sum(1 for i in self.issues if i.severity == "warning")
-
-    def summary(self) -> str:
-        status = "PASS" if self.machinable else "FAIL"
-        lines = [
-            f"CNC Validation [{status}] — {self.part_name}",
-            f"  Recommended: {self.axis_recommendation} milling",
-            f"  Errors: {self.error_count} | Warnings: {self.warning_count}",
-        ]
-        for issue in self.issues:
-            icon = {"error": "✗", "warning": "⚠", "info": "ℹ"}[issue.severity]
-            lines.append(f"  {icon} [{issue.category}] {issue.message}")
-        return "\n".join(lines)
-
-
-# --- Configurable thresholds ---
-
-DEFAULT_CONFIG = {
-    "min_wall_thickness_mm": 1.5,
-    "min_fillet_radius_mm": 1.0,  # Typical smallest endmill radius
-    "max_pocket_depth_ratio": 4.0,  # depth / width ratio
-    "max_part_size_mm": 500.0,  # Typical CNC work envelope
-    "min_part_size_mm": 1.0,
-    "min_hole_diameter_mm": 1.0,
-}
-
-
-def validate_for_cnc(
-    workplane: cq.Workplane,
-    part_name: str = "Part",
-    config: Optional[dict] = None,
-) -> CNCValidationResult:
-    """
-    Run manufacturability checks on a CadQuery solid.
-    Returns a CNCValidationResult with issues found.
-    """
-    cfg = {**DEFAULT_CONFIG, **(config or {})}
-    result = CNCValidationResult(part_name=part_name)
-    shape = workplane.val()
-    bb = shape.BoundingBox()
-
-    # --- 1. Bounding box / size checks ---
-    dims = sorted([bb.xlen, bb.ylen, bb.zlen])
-    max_dim = dims[-1]
-    min_dim = dims[0]
-
-    if max_dim > cfg["max_part_size_mm"]:
-        result.issues.append(
-            CNCIssue(
-                "error",
-                "Size",
-                f"Part too large: {max_dim:.1f}mm exceeds {cfg['max_part_size_mm']}mm work envelope",
-            )
-        )
-        result.machinable = False
-
-    if min_dim < cfg["min_part_size_mm"]:
-        result.issues.append(
-            CNCIssue(
-                "warning",
-                "Size",
-                f"Very small dimension: {min_dim:.2f}mm — may be difficult to fixture",
-            )
-        )
-
-    # --- 2. Volume sanity check ---
-    volume = shape.Volume()
-    bb_volume = bb.xlen * bb.ylen * bb.zlen
-    if bb_volume > 0:
-        fill_ratio = volume / bb_volume
-        if fill_ratio < 0.05:
-            result.issues.append(
-                CNCIssue(
-                    "warning",
-                    "Geometry",
-                    f"Very low fill ratio ({fill_ratio:.1%}) — complex geometry, high machining time",
-                )
-            )
-        result.issues.append(
-            CNCIssue(
-                "info",
-                "Geometry",
-                f"Fill ratio: {fill_ratio:.1%} (volume/bounding box)",
-            )
-        )
-
-    # --- 3. Face and edge complexity ---
-    faces = workplane.faces().vals()
-    edges = workplane.edges().vals()
-
-    n_faces = len(faces)
-    n_edges = len(edges)
-
-    if n_faces > 100:
-        result.issues.append(
-            CNCIssue(
-                "warning",
-                "Complexity",
-                f"{n_faces} faces detected — may require multi-setup or 5-axis",
-            )
-        )
-        result.axis_recommendation = "5-axis"
-    elif n_faces > 50:
-        result.issues.append(
-            CNCIssue(
-                "info",
-                "Complexity",
-                f"{n_faces} faces — consider 4-axis or indexed 5-axis",
-            )
-        )
-        result.axis_recommendation = "3+2 axis"
-
-    # --- 4. Edge length analysis (thin feature proxy) ---
-    edge_lengths = []
-    for edge in edges:
-        try:
-            edge_lengths.append(edge.Length())
-        except Exception:
-            pass
-
-    if edge_lengths:
-        min_edge = min(edge_lengths)
-        if min_edge < cfg["min_wall_thickness_mm"]:
-            result.issues.append(
-                CNCIssue(
-                    "warning",
-                    "Thin Feature",
-                    f"Shortest edge: {min_edge:.2f}mm — below min wall thickness "
-                    f"({cfg['min_wall_thickness_mm']}mm)",
-                )
-            )
-
-    # --- 5. Aspect ratio check (deep pocket heuristic) ---
-    # Only flag if the narrowest dimension is small enough to be a pocket/slot
-    if dims[0] > 0 and dims[0] < 20:
-        aspect = dims[2] / dims[0]  # tallest / narrowest
-        if aspect > cfg["max_pocket_depth_ratio"]:
-            result.issues.append(
-                CNCIssue(
-                    "warning",
-                    "Deep Feature",
-                    f"Aspect ratio {aspect:.1f}:1 — may require long-reach tooling or "
-                    f"special fixturing",
-                )
-            )
-
-    # --- 6. Surface type analysis ---
-    has_freeform = False
-    planar_count = 0
-    cylindrical_count = 0
-
-    for face in faces:
-        try:
-            geom_type = face.geomType()
-            if geom_type == "PLANE":
-                planar_count += 1
-            elif geom_type == "CYLINDER":
-                cylindrical_count += 1
-            elif geom_type in ("BSPLINE", "BEZIER", "OTHER"):
-                has_freeform = True
-        except Exception:
-            pass
-
-    if has_freeform:
-        result.issues.append(
-            CNCIssue(
-                "warning",
-                "Surface",
-                "Freeform/spline surfaces detected — requires 3D contouring toolpaths",
-            )
-        )
-        if result.axis_recommendation == "3-axis":
-            result.axis_recommendation = "3-axis (with 3D finishing)"
-
-    result.issues.append(
-        CNCIssue(
-            "info",
-            "Surface",
-            f"Faces: {planar_count} planar, {cylindrical_count} cylindrical, "
-            f"{n_faces - planar_count - cylindrical_count} other",
-        )
-    )
-
-    # --- 7. Set final machinable flag ---
-    if result.error_count > 0:
-        result.machinable = False
-
-    return result

code_executor.py

@@ -1,189 +0,0 @@
-"""
-Safe CadQuery code execution engine.
-Executes LLM-generated CadQuery code in a sandboxed namespace,
-validates the result, and exports to STEP/STL.
-"""
-
-import io
-import sys
-import traceback
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Optional
-
-import cadquery as cq
-
-
-@dataclass
-class ExecutionResult:
-    """Result of executing a CadQuery script."""
-    success: bool
-    result: Optional[cq.Workplane] = None
-    code: str = ""
-    error: Optional[str] = None
-    stdout: str = ""
-    volume: float = 0.0
-    bounding_box: tuple = ()
-    face_count: int = 0
-    edge_count: int = 0
-
-    def summary(self) -> str:
-        if not self.success:
-            return f"FAILED: {self.error}"
-        bb = self.bounding_box
-        return (
-            f"OK | Volume: {self.volume:.1f} mm³ | "
-            f"BBox: {bb[0]:.1f}×{bb[1]:.1f}×{bb[2]:.1f} mm | "
-            f"Faces: {self.face_count} | Edges: {self.edge_count}"
-        )
-
-
-# Allowed imports in the sandboxed namespace
-SAFE_NAMESPACE = {
-    "cq": cq,
-    "cadquery": cq,
-    "math": __import__("math"),
-    "__builtins__": {
-        "range": range,
-        "len": len,
-        "abs": abs,
-        "min": min,
-        "max": max,
-        "round": round,
-        "int": int,
-        "float": float,
-        "tuple": tuple,
-        "list": list,
-        "True": True,
-        "False": False,
-        "None": None,
-        "print": print,
-        "enumerate": enumerate,
-        "zip": zip,
-        "__import__": __import__,
-    },
-}
-
-
-def sanitize_code(code: str) -> str:
-    """Clean up LLM output — strip markdown fences, trailing whitespace,
-    and redundant import statements (already in namespace)."""
-    code = code.strip()
-
-    # Remove markdown code fences if present
-    if code.startswith("```python"):
-        code = code[len("```python"):]
-    elif code.startswith("```"):
-        code = code[3:]
-    if code.endswith("```"):
-        code = code[:-3]
-
-    # Strip import lines for modules already in namespace
-    lines = code.strip().splitlines()
-    cleaned = []
-    for line in lines:
-        stripped = line.strip()
-        # Keep the line unless it's a redundant cadquery/math import
-        if stripped.startswith("import cadquery") or stripped.startswith("from cadquery"):
-            continue
-        if stripped == "import math":
-            continue
-        cleaned.append(line)
-
-    return "\n".join(cleaned).strip()
-
-
-def execute_cadquery(code: str) -> ExecutionResult:
-    """
-    Execute a CadQuery script string and return the result.
-    The script must assign its output to a variable called `result`.
-    """
-    code = sanitize_code(code)
-
-    # Capture stdout
-    old_stdout = sys.stdout
-    sys.stdout = captured = io.StringIO()
-
-    namespace = dict(SAFE_NAMESPACE)
-
-    try:
-        exec(code, namespace)  # noqa: S102
-    except Exception:
-        sys.stdout = old_stdout
-        return ExecutionResult(
-            success=False,
-            code=code,
-            error=traceback.format_exc(),
-            stdout=captured.getvalue(),
-        )
-
-    sys.stdout = old_stdout
-    stdout_text = captured.getvalue()
-
-    # Extract the result
-    result_obj = namespace.get("result")
-    if result_obj is None:
-        return ExecutionResult(
-            success=False,
-            code=code,
-            error="Script did not assign a value to `result`.",
-            stdout=stdout_text,
-        )
-
-    if not isinstance(result_obj, cq.Workplane):
-        return ExecutionResult(
-            success=False,
-            code=code,
-            error=f"Expected cq.Workplane, got {type(result_obj).__name__}",
-            stdout=stdout_text,
-        )
-
-    # Extract geometry metadata
-    try:
-        shape = result_obj.val()
-        bb = result_obj.val().BoundingBox()
-        bbox_dims = (bb.xlen, bb.ylen, bb.zlen)
-        volume = shape.Volume()
-        faces = len(result_obj.faces().vals())
-        edges = len(result_obj.edges().vals())
-    except Exception as e:
-        return ExecutionResult(
-            success=False,
-            code=code,
-            error=f"Geometry extraction failed: {e}",
-            stdout=stdout_text,
-        )
-
-    return ExecutionResult(
-        success=True,
-        result=result_obj,
-        code=code,
-        stdout=stdout_text,
-        volume=volume,
-        bounding_box=bbox_dims,
-        face_count=faces,
-        edge_count=edges,
-    )
-
-
-def export_step(result: cq.Workplane, path: str | Path) -> Path:
-    """Export a CadQuery workplane to STEP format."""
-    path = Path(path)
-    cq.exporters.export(result, str(path), exportType="STEP")
-    return path
-
-
-def export_stl(result: cq.Workplane, path: str | Path, tolerance: float = 0.01) -> Path:
-    """Export a CadQuery workplane to STL format."""
-    path = Path(path)
-    cq.exporters.export(result, str(path), exportType="STL", tolerance=tolerance)
-    return path
-
-
-def export_all(result: cq.Workplane, base_path: str | Path) -> dict[str, Path]:
-    """Export to both STEP and STL."""
-    base = Path(base_path)
-    return {
-        "step": export_step(result, base.with_suffix(".step")),
-        "stl": export_stl(result, base.with_suffix(".stl")),
-    }

docker-compose.yml

@@ -4,6 +4,10 @@ services:
     command: python -m server.mcp --transport sse --port 8000
     ports:
       - "8000:8000"
+    environment:
+      GEMINI_API_KEY: ${GEMINI_API_KEY:-}
+      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
+      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
     volumes:
       - ./output:/app/output
 

docs/superpowers/specs/2026-04-08-multi-agent-chat-design.md

@@ -0,0 +1,390 @@
+# NeuralCAD Multi-Agent Chat Design
+
+## Context
+
+NeuralCAD currently uses a single-prompt flow: user describes a part, one LLM call generates CadQuery code, and the result renders in a 3D viewer. This works for simple parts but doesn't support iterative design refinement.
+
+The goal is to replace this with a **multi-agent chat experience** where 4 specialized AI agents (Design, Engineering, CNC, CAD Coder) collaborate with the user in a shared conversation to plan and refine a mechanical part before generating the 3D model. The user drives the conversation, agents contribute their expertise, and the user can request a 3D preview on demand.
+
+## Agent Definitions
+
+Four agents participate in a shared group chat. Each has a distinct role, color, and expertise:
+
+| Agent | ID | Color | Avatar | Role |
+|-------|----|-------|--------|------|
+| Design Agent | `design` | `#7c3aed` (purple) | DA | Industrial/product design: shape, form, aesthetics, ergonomics. Asks about intent, proposes form factors, considers user experience. |
+| Engineering Agent | `engineering` | `#00b4d8` (cyan) | EA | Structural/mechanical: dimensions, tolerances, materials, stress analysis, fastener specs (M3/M4/M6 clearance holes). |
+| CNC/Manufacturing Agent | `cnc` | `#00e676` (green) | CA | Manufacturability: tool access, wall thickness, pocket aspect ratios, axis requirements, fixturing, cost implications. |
+| CAD Coder Agent | `cad` | `#ffab40` (amber) | CC | Code generation: takes the agreed design and produces CadQuery Python code. Only responds when a preview is requested. |
+
+## Orchestration Architecture
+
+### Hybrid Approach: CrewAI Agents + Custom Orchestrator
+
+Use **CrewAI** for agent definitions (roles, goals, backstories) and the `BaseLLM` adapter pattern, but implement **two orchestration modes**:
+
+#### Single-Call Mode (Gemini Free Tier / Mock)
+
+One LLM call per user turn. The system prompt contains all agent personas and routing rules. The LLM returns a structured JSON response:
+
+```json
+{
+  "agents": [
+    {"id": "design", "message": "For an MG996R servo, I'd suggest an L-bracket..."},
+    {"id": "engineering", "message": "3mm wall thickness in aluminum 6061..."}
+  ]
+}
+```
+
+The orchestrator system prompt instructs the LLM to:
+- Analyze the user's message and conversation context
+- Select 1-3 relevant agents to respond (never all four unless appropriate)
+- Generate each agent's response in character
+- Only include the `cad` agent when the user explicitly requests a preview
+- When `cad` responds, include a `code` field with valid CadQuery Python
+
+If the user @mentions specific agents, the system prompt is modified to only include those agents.
+
+**Fallback**: If JSON parsing fails, use rule-based keyword matching to select agents and re-call the LLM with a simpler prompt for just those agents.
+
+#### Multi-Call Mode (Anthropic / OpenAI)
+
+CrewAI's hierarchical process with a manager agent. Each agent gets its own LLM call with focused context. The manager routes based on conversation state. Better quality but uses 2-4 API calls per turn.
+
+#### Mode Selection
+
+| Backend | Mode | Reason |
+|---------|------|--------|
+| `mock` | Template-based | No LLM call. Returns canned agent responses based on keyword matching. For the CAD Coder agent, delegates to the existing MockBackend which generates CadQuery code from prompt parsing. Useful for UI development and demos without API keys. |
+| `gemini` | Single-call | Free tier rate limits (15 RPM) |
+| `anthropic` | Multi-call | Paid API, better quality |
+| `openai` | Multi-call | Paid API, better quality |
+
+### @Mention System
+
+Users can direct messages to specific agents by typing `@design`, `@engineering`, `@cnc`, or `@cad` in their message.
+
+- Frontend parses @mentions from the message text before sending
+- @mentions are sent as a `mentions` array in the API request
+- When mentions are present:
+  - Single-call mode: system prompt only includes mentioned agents' personas
+  - Multi-call mode: only mentioned agents are activated in the crew
+- When no mentions: orchestrator decides which agents respond
+- `@cad` triggers CAD code generation (same as clicking the preview button)
+
+### Agent Prompt Structure
+
+Each agent has:
+- **System persona**: role description, expertise, communication style
+- **Conversation context**: last N messages from the chat history
+- **User message**: the current message with @mention context
+
+The CAD Coder agent additionally receives:
+- The full CadQuery system prompt (from `cadquery_system_prompt.py`)
+- Few-shot examples of CadQuery code
+- A summary of design decisions from the conversation so far
+
+## Chat API
+
+### Endpoint: `POST /api/chat`
+
+**Request:**
+```json
+{
+  "history": [
+    {"role": "user", "content": "I need a servo bracket"},
+    {"role": "design", "content": "What type of servo?"},
+    {"role": "user", "content": "MG996R, for a camera gimbal"}
+  ],
+  "message": "Make it 60mm wide with M4 base mounting",
+  "mentions": [],
+  "backend": "gemini"
+}
+```
+
+**Response:**
+```json
+{
+  "responses": [
+    {
+      "agent_id": "design",
+      "agent_name": "Design Agent",
+      "message": "L-bracket with servo pocket on vertical face...",
+      "color": "#7c3aed",
+      "avatar": "DA"
+    },
+    {
+      "agent_id": "engineering",
+      "agent_name": "Engineering Agent",
+      "message": "3mm walls, 5mm fillet on the L-bend...",
+      "color": "#00b4d8",
+      "avatar": "EA"
+    }
+  ],
+  "preview": null
+}
+```
+
+**Response with preview (when CAD Coder responds):**
+```json
+{
+  "responses": [
+    {
+      "agent_id": "cad",
+      "agent_name": "CAD Coder",
+      "message": "Model generated successfully.",
+      "color": "#ffab40",
+      "avatar": "CC",
+      "code": "import cadquery as cq\nresult = cq.Workplane('XY')..."
+    }
+  ],
+  "preview": {
+    "part_name": "servo_bracket",
+    "stl_url": "/api/models/servo_bracket.stl",
+    "step_url": "/api/models/servo_bracket.step",
+    "execution": {
+      "success": true,
+      "volume_mm3": 4230.5,
+      "bounding_box_mm": [60.0, 43.0, 25.0],
+      "face_count": 34,
+      "edge_count": 52
+    },
+    "validation": {
+      "machinable": true,
+      "axis_recommendation": "3-axis",
+      "issues": []
+    }
+  }
+}
+```
+
+### State Management
+
+- **Stateless backend**: frontend sends full conversation history with each request
+- **Backend truncation**: history truncated to last 30 messages to stay within token limits
+- **No sessions**: no server-side session storage needed
+- **Gallery persistence**: saved models stored in the `output/` directory with metadata JSON files
+
+### Existing Endpoints (Preserved)
+
+- `GET /api/models` — list generated models
+- `GET /api/models/{name}.stl` — download STL
+- `GET /api/models/{name}.step` — download STEP
+- `GET /api/capabilities` — server status
+
+### New Endpoint: `POST /api/report`
+
+Generates a design report document. Requires conversation history since the backend is stateless.
+
+**Request:**
+```json
+{
+  "part_name": "servo_bracket",
+  "history": [...],
+  "backend": "gemini"
+}
+```
+
+The LLM summarizes the conversation into a report containing:
+- Design decisions extracted from conversation
+- Final dimensions and specifications
+- CNC validation results and axis recommendation
+- Agent recommendations summary
+
+For `mock` backend, the report is assembled from the last CAD Coder response metadata without an LLM call.
+
+## Frontend Design
+
+### Layout: Fullscreen 3D Viewer + Slide-out Chat
+
+The 3D viewer occupies the **entire viewport** as the primary element. The chat panel slides in/out from the right side.
+
+```
++--[TopBar: Logo | Backend Toggle | Status]------------------+
+|                                                    |  CHAT  |
+|                                                    | PANEL  |
+|              FULLSCREEN 3D VIEWER                  | (340px)|
+|              (Three.js WebGL)                      |        |
+|                                                    | [msgs] |
+|  [Geo Stats]                         [CNC Badge]  | [msgs] |
+|                                                    | [msgs] |
+|                                                    |--------|
+|  [STEP] [STL] [Report]                             |[input] |
++----------------------------------------------------+--------+
+```
+
+### 3D Viewer
+
+- Same Three.js setup as current (STLLoader, OrbitControls, MeshPhongMaterial)
+- Fullscreen, edge-to-edge behind the chat panel
+- Semi-transparent overlays for geo stats (top-left), CNC badge (top-right of viewer area), downloads (bottom-left)
+- Empty state shows a subtle prompt: "Start a conversation to design your part"
+- When model is loaded: auto-centers, fits camera to bounding box, slow auto-rotate when idle
+
+### Chat Panel
+
+- **Width**: 340px, slides in from right
+- **Background**: semi-transparent (`rgba(10,14,20,0.92)`) with `backdrop-filter: blur(16px)` so the 3D model is visible behind
+- **Collapse/expand**: toggle button (chevron) in chat header, or floating pill at bottom center when collapsed
+- **Agent dots**: row of 4 colored dots in the header showing active agents
+
+#### Message Rendering
+
+- **User messages**: right-aligned, dark blue bubble (`#1a2a3a`), rounded corners
+- **Agent messages**: left-aligned with colored avatar circle (24px), agent label above message text in agent's color
+- **CAD Coder messages**: distinct background (`rgba(255,171,64,0.08)`) with "View CadQuery code" link
+
+#### Input Area
+
+- Text input with placeholder "Type your message..."
+- **@mention autocomplete**: typing `@` shows a dropdown with agent names, selecting inserts `@design` etc.
+- **Preview button** (eye icon, amber `#ffab40`): triggers CAD Coder to generate 3D model from current conversation
+- **Send button** (arrow icon, cyan `#00b4d8`): sends the message
+- **Ctrl/Cmd+Enter**: keyboard shortcut to send
+
+#### Quick Examples
+
+On first load (empty chat), show example conversation starters as clickable chips:
+- "Design a mounting bracket for an MG996R servo"
+- "I need a spur gear with 20 teeth"
+- "Create a heatsink for a 30mm cylinder"
+- "Design a pipe flange with M8 bolt holes"
+
+These insert the text into the chat input and auto-send.
+
+### Gallery
+
+- Accessed via a button in the top bar (not a tab)
+- Opens as a modal/dropdown overlay
+- Shows previously generated models as cards with thumbnail, name, face count, CNC status
+- Click to load model into the 3D viewer
+
+### Backend Toggle
+
+- Same as current: MOCK / GEMINI / CLAUDE radio buttons in the top bar
+- Changing backend affects which orchestration mode is used (single-call vs multi-call)
+
+## Refactored File Structure
+
+```
+NeuralCAD/
+├── agents/
+│   ├── __init__.py
+│   ├── definitions.py          # CrewAI Agent + Task definitions for all 4 agents
+│   ├── orchestrator.py         # Single-call JSON orchestrator (Gemini/Mock mode)
+│   ├── crew_orchestrator.py    # Multi-call CrewAI hierarchical process (Anthropic/OpenAI)
+│   ├── llm_adapter.py          # CrewAI BaseLLM wrapper around LLMBackend
+│   └── prompts.py              # Agent system prompts, personas, routing rules
+├── core/
+│   ├── __init__.py
+│   ├── backends.py             # LLMBackend base + AnthropicBackend, OpenAIBackend,
+│   │                           #   GeminiBackend, MockBackend (extracted from pipeline.py)
+│   ├── executor.py             # Sandboxed CadQuery execution (from code_executor.py)
+│   ├── validator.py            # CNC validation (from cnc_validator.py)
+│   ├── cadquery_prompts.py     # CadQuery system prompt + few-shot examples
+│   │                           #   (from cadquery_system_prompt.py)
+│   └── pipeline.py             # run_pipeline() for CAD generation
+│   │                           #   (simplified, called by CAD Coder agent)
+├── server/
+│   ├── __init__.py
+│   ├── web.py                  # FastAPI app, static file serving (from web_server.py)
+│   ├── mcp.py                  # MCP server + tools (from mcp_server.py)
+│   └── routes.py               # /api/chat, /api/report endpoints
+├── web/
+│   └── index.html              # Complete rewrite: fullscreen 3D viewer + slide-out chat
+├── pyproject.toml              # + crewai dependency
+├── Dockerfile                  # Updated for new structure
+├── docker-compose.yml          # Same services, updated paths
+└── entrypoint.sh               # Updated entry point
+```
+
+### Key Refactoring Notes
+
+- `pipeline.py` (922 lines) is split into `core/backends.py` (LLM backends), `core/pipeline.py` (run_pipeline), and `agents/` (orchestration)
+- `code_executor.py` → `core/executor.py` (unchanged logic)
+- `cnc_validator.py` → `core/validator.py` (unchanged logic)
+- `cadquery_system_prompt.py` → `core/cadquery_prompts.py` (unchanged logic)
+- `web_server.py` → `server/web.py` + `server/routes.py`
+- `mcp_server.py` → `server/mcp.py` (add `chat_turn` MCP tool for Claude Desktop)
+- `web/index.html` → complete rewrite
+
+## Data Flow: Chat Turn
+
+```
+1. User types message in chat UI
+2. Frontend parses @mentions from message text
+3. POST /api/chat { history, message, mentions, backend }
+         |
+4. Backend selects orchestration mode:
+   ├── gemini/mock → Single-call orchestrator
+   │     ├── Build system prompt with agent personas + routing rules
+   │     ├── Include conversation history (last 30 msgs)
+   │     ├── If @mentions: only include mentioned agent personas
+   │     ├── LLMBackend.generate(messages) → JSON string
+   │     ├── Parse JSON → list of agent responses
+   │     └── Fallback: keyword routing + simpler re-call if JSON fails
+   │
+   └── anthropic/openai → CrewAI hierarchical process
+         ├── Manager agent routes to relevant agents
+         ├── Each agent gets own LLM call via NeuralCADLLMAdapter
+         └── Collect responses from all activated agents
+         |
+5. If CAD Coder agent responded with code:
+   ├── execute_cadquery(code) → ExecutionResult
+   ├── export_step() + export_stl() → files in output/
+   ├── validate_for_cnc() → CNCValidationResult
+   └── Build preview object with URLs and metadata
+         |
+6. Return JSON response → Frontend renders agent messages
+         |
+7. If preview present:
+   ├── Load STL into Three.js viewer
+   ├── Show geo stats overlay
+   ├── Show CNC badge
+   └── Enable download buttons
+```
+
+## MCP Compatibility
+
+Add a new `chat_turn` MCP tool alongside existing tools:
+
+```python
+@mcp.tool()
+async def chat_turn(
+    message: str,
+    history: list[dict] | None = None,
+    mentions: list[str] | None = None,
+    backend: str = "gemini"
+) -> dict:
+    """Multi-agent chat turn for collaborative CAD design."""
+```
+
+Existing MCP tools (`generate_cnc_model`, `validate_cnc_model`, `execute_cadquery_code`, `list_models`) remain unchanged for backward compatibility with Claude Desktop.
+
+## Verification Plan
+
+### Unit Tests
+- Test single-call orchestrator JSON parsing with valid and malformed responses
+- Test @mention parsing in frontend
+- Test keyword-based fallback routing
+- Test LLM adapter wraps LLMBackend correctly
+
+### Integration Tests
+- Full chat turn: user message → agent responses → verify correct agents selected
+- Preview generation: chat with `@cad` → verify STL/STEP files created
+- Backend switching: verify single-call mode for Gemini, multi-call for Anthropic
+- Conversation history truncation at 30 messages
+
+### Manual Testing
+- Open web UI, start a conversation about a servo bracket
+- Verify agents respond with appropriate expertise
+- Use @mentions to direct messages to specific agents
+- Click preview button → verify 3D model loads
+- Download STEP and STL files
+- Collapse/expand chat panel
+- Test with Gemini free tier (rate limit behavior)
+- Test quick example conversation starters
+
+### MCP Testing
+- Call `chat_turn` tool from Claude Desktop
+- Verify existing MCP tools still work

mcp_server.py

@@ -1,446 +0,0 @@
-#!/usr/bin/env python3
-"""
-Text-to-CNC MCP Server
-======================
-Exposes the text-to-CNC pipeline as MCP tools over stdio transport.
-
-Tools:
-  - generate_cnc_model: Text prompt → CadQuery code → 3D solid → STEP/STL
-  - validate_cnc_model: Run CNC manufacturability checks on CadQuery code
-  - execute_cadquery:   Run arbitrary CadQuery code and get geometry info
-  - list_models:        List previously generated models in the output dir
-
-Usage:
-  python mcp_server.py                    # stdio transport (default)
-  python mcp_server.py --transport sse    # SSE transport on port 8000
-"""
-
-import json
-import os
-import sys
-from pathlib import Path
-
-from mcp.server.fastmcp import FastMCP
-
-# Ensure the project modules are importable
-sys.path.insert(0, str(Path(__file__).parent))
-
-from cadquery_system_prompt import build_messages, CADQUERY_SYSTEM_PROMPT
-from code_executor import ExecutionResult, execute_cadquery, export_all, sanitize_code
-from cnc_validator import validate_for_cnc, CNCValidationResult
-
-# ── Server Setup ──────────────────────────────────────────────────────────
-
-mcp = FastMCP(
-    "text-to-cnc",
-    instructions=(
-        "Generate CNC-machinable 3D models from text descriptions. "
-        "Converts natural language → CadQuery code → validated STEP/STL files. "
-        "Version 1.0.0"
-    ),
-)
-
-DEFAULT_OUTPUT_DIR = Path(__file__).parent / "output"
-DEFAULT_OUTPUT_DIR.mkdir(exist_ok=True)
-
-
-# ── Helper: LLM Backend Selection ────────────────────────────────────────
-
-def get_backend(backend_name: str = "mock"):
-    """Get the appropriate LLM backend."""
-    from pipeline import MockBackend, AnthropicBackend, OpenAIBackend, GeminiBackend, NeuralCADBackend
-
-    if backend_name == "neural":
-        return NeuralCADBackend()
-    elif backend_name == "anthropic" and os.environ.get("ANTHROPIC_API_KEY"):
-        return AnthropicBackend()
-    elif backend_name == "openai" and os.environ.get("OPENAI_API_KEY"):
-        return OpenAIBackend()
-    elif backend_name == "gemini" and os.environ.get("GEMINI_API_KEY"):
-        return GeminiBackend()
-    else:
-        return MockBackend()
-
-
-# ── Tool: generate_cnc_model ─────────────────────────────────────────────
-
-@mcp.tool()
-def generate_cnc_model(
-    prompt: str,
-    part_name: str = "",
-    backend: str = "mock",
-    max_retries: int = 2,
-    output_format: str = "both",
-) -> str:
-    """
-    Generate a CNC-machinable 3D model from a text description.
-
-    Takes a natural language description of a mechanical part, generates
-    CadQuery Python code via an LLM, executes it to produce a 3D solid,
-    validates it for CNC manufacturability, and exports STEP/STL files.
-
-    Args:
-        prompt: Natural language description of the part to generate.
-                Example: "A mounting bracket with four M6 bolt holes, 80mm wide"
-        part_name: Optional name for the part (used in filenames).
-                   If empty, auto-generated from the prompt.
-        backend: LLM backend to use: "mock" (no API key), "anthropic", or "openai".
-        max_retries: Number of retry attempts if code generation fails (0-3).
-        output_format: Export format: "step", "stl", or "both".
-
-    Returns:
-        JSON string with generation results including:
-        - generated_code: The CadQuery Python code
-        - execution: Success/failure status and geometry metadata
-        - validation: CNC manufacturability analysis
-        - exported_files: Paths to generated STEP/STL files
-    """
-    from pipeline import run_pipeline
-
-    if not part_name:
-        part_name = prompt[:40].strip().replace(" ", "_").lower()
-        part_name = "".join(c for c in part_name if c.isalnum() or c == "_")
-
-    llm_backend = get_backend(backend)
-
-    result = run_pipeline(
-        prompt=prompt,
-        backend=llm_backend,
-        output_dir=DEFAULT_OUTPUT_DIR,
-        max_retries=min(max_retries, 3),
-        export=True,
-        validate=True,
-        part_name=part_name,
-    )
-
-    # Build response
-    response = {
-        "success": result.execution.success,
-        "prompt": prompt,
-        "part_name": part_name,
-        "retries": result.retry_count,
-        "generated_code": result.generated_code,
-        "execution": {
-            "success": result.execution.success,
-            "volume_mm3": result.execution.volume,
-            "bounding_box_mm": list(result.execution.bounding_box) if result.execution.bounding_box else [],
-            "face_count": result.execution.face_count,
-            "edge_count": result.execution.edge_count,
-            "error": result.execution.error,
-        },
-    }
-
-    if result.validation:
-        response["validation"] = {
-            "machinable": result.validation.machinable,
-            "axis_recommendation": result.validation.axis_recommendation,
-            "error_count": result.validation.error_count,
-            "warning_count": result.validation.warning_count,
-            "issues": [
-                {"severity": i.severity, "category": i.category, "message": i.message}
-                for i in result.validation.issues
-            ],
-        }
-
-    if result.exported_files:
-        response["exported_files"] = {
-            fmt: str(path) for fmt, path in result.exported_files.items()
-        }
-
-    return json.dumps(response, indent=2)
-
-
-# ── Tool: validate_cnc_model ─────────────────────────────────────────────
-
-@mcp.tool()
-def validate_cnc_model(
-    cadquery_code: str,
-    part_name: str = "Part",
-    min_wall_thickness_mm: float = 1.5,
-    max_part_size_mm: float = 500.0,
-) -> str:
-    """
-    Validate CadQuery code for CNC manufacturability without generating new code.
-
-    Executes the provided CadQuery code, then runs manufacturability checks
-    including wall thickness, tool access, aspect ratios, and surface complexity.
-
-    Args:
-        cadquery_code: Valid CadQuery Python code that assigns result to `result`.
-                       Example: 'import cadquery as cq\\nresult = cq.Workplane("XY").box(10,10,10)'
-        part_name: Name for the part in the validation report.
-        min_wall_thickness_mm: Minimum acceptable wall thickness in mm (default 1.5).
-        max_part_size_mm: Maximum part dimension in mm (default 500).
-
-    Returns:
-        JSON string with execution status and CNC validation results including
-        machinable flag, axis recommendation, and list of issues.
-    """
-    exec_result = execute_cadquery(cadquery_code)
-
-    response = {
-        "execution_success": exec_result.success,
-        "error": exec_result.error,
-        "volume_mm3": exec_result.volume,
-        "bounding_box_mm": list(exec_result.bounding_box) if exec_result.bounding_box else [],
-    }
-
-    if exec_result.success:
-        config = {
-            "min_wall_thickness_mm": min_wall_thickness_mm,
-            "max_part_size_mm": max_part_size_mm,
-        }
-        validation = validate_for_cnc(exec_result.result, part_name=part_name, config=config)
-        response["validation"] = {
-            "machinable": validation.machinable,
-            "axis_recommendation": validation.axis_recommendation,
-            "error_count": validation.error_count,
-            "warning_count": validation.warning_count,
-            "issues": [
-                {"severity": i.severity, "category": i.category, "message": i.message}
-                for i in validation.issues
-            ],
-            "summary": validation.summary(),
-        }
-
-    return json.dumps(response, indent=2)
-
-
-# ── Tool: execute_cadquery ───────────────────────────────────────────────
-
-@mcp.tool()
-def execute_cadquery_code(
-    code: str,
-    export_path: str = "",
-) -> str:
-    """
-    Execute CadQuery Python code and return geometry information.
-
-    Runs CadQuery code in a sandboxed environment and returns metadata
-    about the resulting 3D solid (volume, bounding box, face/edge counts).
-    Optionally exports to STEP/STL.
-
-    Args:
-        code: CadQuery Python code. Must assign the final solid to a variable
-              called `result`. Example:
-              'import cadquery as cq\\nresult = cq.Workplane("XY").box(20,20,20).hole(8)'
-        export_path: Optional base file path for STEP/STL export (without extension).
-                     Example: "output/my_part" → creates my_part.step and my_part.stl
-
-    Returns:
-        JSON string with execution results including success status,
-        geometry metadata, stdout output, and export file paths if requested.
-    """
-    exec_result = execute_cadquery(code)
-
-    response = {
-        "success": exec_result.success,
-        "error": exec_result.error,
-        "stdout": exec_result.stdout,
-        "volume_mm3": exec_result.volume,
-        "bounding_box_mm": list(exec_result.bounding_box) if exec_result.bounding_box else [],
-        "face_count": exec_result.face_count,
-        "edge_count": exec_result.edge_count,
-    }
-
-    if exec_result.success and export_path:
-        try:
-            files = export_all(exec_result.result, export_path)
-            response["exported_files"] = {fmt: str(p) for fmt, p in files.items()}
-        except Exception as e:
-            response["export_error"] = str(e)
-
-    return json.dumps(response, indent=2)
-
-
-# ── Tool: list_models ────────────────────────────────────────────────────
-
-@mcp.tool()
-def list_models(output_dir: str = "") -> str:
-    """
-    List all previously generated CNC models in the output directory.
-
-    Returns a list of generated STEP and STL files with their sizes.
-
-    Args:
-        output_dir: Directory to scan. Defaults to the server's output directory.
-
-    Returns:
-        JSON string with a list of model files and their sizes in bytes.
-    """
-    scan_dir = Path(output_dir) if output_dir else DEFAULT_OUTPUT_DIR
-
-    if not scan_dir.exists():
-        return json.dumps({"error": f"Directory not found: {scan_dir}"})
-
-    models = {}
-    for ext in ("*.step", "*.stl"):
-        for f in scan_dir.glob(ext):
-            name = f.stem
-            if name not in models:
-                models[name] = {"name": name, "files": {}}
-            models[name]["files"][f.suffix.lstrip(".")] = {
-                "path": str(f),
-                "size_bytes": f.stat().st_size,
-            }
-
-    return json.dumps({
-        "output_dir": str(scan_dir),
-        "model_count": len(models),
-        "models": list(models.values()),
-    }, indent=2)
-
-
-# ── Tool: generate_from_image ───────────────────────────────────────────
-
-@mcp.tool()
-def generate_from_image(
-    image_path: str,
-    text_hint: str = "",
-    part_name: str = "",
-    backend: str = "anthropic",
-    max_retries: int = 2,
-) -> str:
-    """
-    Generate a CNC-machinable 3D model from a photo or sketch image.
-
-    Sends the image to a vision-capable LLM (Claude or GPT-4o) along with
-    the CadQuery system prompt to generate code, then executes, validates,
-    and exports the result.
-
-    Args:
-        image_path: Path to an image file (photo, sketch, or CAD screenshot).
-        text_hint: Optional text to guide generation alongside the image.
-                   Example: "This is a mounting bracket — add M6 bolt holes"
-        part_name: Optional name for the part (used in filenames).
-        backend: LLM backend: "anthropic" or "openai". Must support vision.
-        max_retries: Number of retry attempts if code execution fails (0-3).
-
-    Returns:
-        JSON string with generation results including generated code,
-        execution status, validation, and exported file paths.
-    """
-    if not Path(image_path).exists():
-        return json.dumps({"success": False, "error": f"Image not found: {image_path}"})
-
-    if not part_name:
-        part_name = Path(image_path).stem
-
-    llm_backend = get_backend(backend)
-
-    # Build prompt with optional text hint
-    prompt = "Generate CadQuery code for the mechanical part shown in this image."
-    if text_hint:
-        prompt += f"\n\nAdditional context: {text_hint}"
-
-    messages = build_messages(prompt)
-
-    # Use vision-capable generate_with_image
-    generated_code = llm_backend.generate_with_image(messages, image_path)
-
-    # Run through standard execution/validation/export
-    exec_result = execute_cadquery(generated_code)
-    retry_count = 0
-
-    while not exec_result.success and retry_count < min(max_retries, 3):
-        retry_count += 1
-        error_feedback = (
-            f"The previous code failed with this error:\n"
-            f"```\n{exec_result.error}\n```\n\n"
-            f"Please fix the code and return only the corrected Python code."
-        )
-        retry_messages = build_messages(error_feedback)
-        generated_code = llm_backend.generate_with_image(retry_messages, image_path)
-        exec_result = execute_cadquery(generated_code)
-
-    response = {
-        "success": exec_result.success,
-        "image_path": image_path,
-        "text_hint": text_hint,
-        "part_name": part_name,
-        "backend": backend,
-        "retries": retry_count,
-        "generated_code": generated_code,
-        "execution": {
-            "success": exec_result.success,
-            "volume_mm3": exec_result.volume,
-            "bounding_box_mm": list(exec_result.bounding_box) if exec_result.bounding_box else [],
-            "face_count": exec_result.face_count,
-            "edge_count": exec_result.edge_count,
-            "error": exec_result.error,
-        },
-    }
-
-    if exec_result.success:
-        validation = validate_for_cnc(exec_result.result, part_name=part_name)
-        response["validation"] = {
-            "machinable": validation.machinable,
-            "axis_recommendation": validation.axis_recommendation,
-            "error_count": validation.error_count,
-            "warning_count": validation.warning_count,
-            "issues": [
-                {"severity": i.severity, "category": i.category, "message": i.message}
-                for i in validation.issues
-            ],
-        }
-
-        base_path = DEFAULT_OUTPUT_DIR / part_name
-        try:
-            exported = export_all(exec_result.result, base_path)
-            response["exported_files"] = {fmt: str(p) for fmt, p in exported.items()}
-        except Exception as e:
-            response["export_error"] = str(e)
-
-    return json.dumps(response, indent=2)
-
-
-# ── Resource: System prompt (for transparency) ───────────────────────────
-
-@mcp.resource("text-to-cnc://system-prompt")
-def get_system_prompt() -> str:
-    """The CadQuery generation system prompt used by the LLM."""
-    return CADQUERY_SYSTEM_PROMPT
-
-
-@mcp.resource("text-to-cnc://capabilities")
-def get_capabilities() -> str:
-    """Server capabilities and configuration."""
-    backends = ["mock (always available)", "neural (local models — requires trained weights)"]
-    if os.environ.get("ANTHROPIC_API_KEY"):
-        backends.append("anthropic (API key detected)")
-    if os.environ.get("OPENAI_API_KEY"):
-        backends.append("openai (API key detected)")
-    if os.environ.get("GEMINI_API_KEY"):
-        backends.append("gemini (API key detected)")
-
-    return json.dumps({
-        "name": "text-to-cnc",
-        "version": "1.0.0",
-        "available_backends": backends,
-        "output_dir": str(DEFAULT_OUTPUT_DIR),
-        "export_formats": ["STEP", "STL"],
-        "cnc_validation": True,
-        "max_retries": 3,
-    }, indent=2)
-
-
-# ── Entry Point ──────────────────────────────────────────────────────────
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Text-to-CNC MCP Server")
-    parser.add_argument(
-        "--transport", choices=["stdio", "sse"], default="stdio",
-        help="MCP transport (default: stdio)"
-    )
-    parser.add_argument(
-        "--port", type=int, default=8000,
-        help="Port for SSE transport (default: 8000)"
-    )
-    args = parser.parse_args()
-
-    if args.transport == "sse":
-        mcp.run(transport="sse")
-    else:
-        mcp.run(transport="stdio")

pipeline.py

@@ -1,921 +0,0 @@
-"""
-Text-to-CNC Pipeline — Main orchestrator.
-
-Pipeline stages:
-  1. Text prompt → LLM → CadQuery code
-  2. CadQuery code → Execute → 3D Solid
-  3. 3D Solid → CNC Validation
-  4. 3D Solid → STEP / STL export
-  5. (Optional) Auto-retry with error feedback if execution fails
-
-Supports multiple LLM backends:
-  - Anthropic Claude (default)
-  - OpenAI GPT-4o
-  - Local / mock (for testing without API keys)
-"""
-
-import base64
-import math
-import mimetypes
-import os
-import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-from cadquery_system_prompt import build_messages
-from code_executor import ExecutionResult, execute_cadquery, export_all
-from cnc_validator import validate_for_cnc, CNCValidationResult
-
-
-# ── LLM Backends ──────────────────────────────────────────────────────────
-
-
-class LLMBackend:
-    """Base class for LLM code generation backends."""
-
-    def generate(self, messages: list[dict]) -> str:
-        raise NotImplementedError
-
-    def generate_with_image(self, messages: list[dict], image_path: str | Path) -> str:
-        """Generate code from messages that include an image.
-        Override in backends that support vision."""
-        raise NotImplementedError(
-            f"{self.__class__.__name__} does not support image input"
-        )
-
-
-class AnthropicBackend(LLMBackend):
-    """Generate CadQuery code using Anthropic Claude."""
-
-    def __init__(
-        self, model: str = "claude-sonnet-4-20250514", api_key: Optional[str] = None
-    ):
-        import anthropic
-
-        self.client = anthropic.Anthropic(
-            api_key=api_key or os.environ.get("ANTHROPIC_API_KEY")
-        )
-        self.model = model
-
-    def generate(self, messages: list[dict]) -> str:
-        # Anthropic uses system param separately
-        system_msg = ""
-        user_messages = []
-        for m in messages:
-            if m["role"] == "system":
-                system_msg = m["content"]
-            else:
-                user_messages.append(m)
-
-        response = self.client.messages.create(
-            model=self.model,
-            max_tokens=4096,
-            system=system_msg,
-            messages=user_messages,
-        )
-        return response.content[0].text
-
-    def generate_with_image(self, messages: list[dict], image_path: str | Path) -> str:
-        image_path = Path(image_path)
-        media_type = mimetypes.guess_type(str(image_path))[0] or "image/png"
-        image_data = base64.b64encode(image_path.read_bytes()).decode("utf-8")
-
-        system_msg = ""
-        user_messages = []
-        for m in messages:
-            if m["role"] == "system":
-                system_msg = m["content"]
-            else:
-                msg = dict(m)
-                # Inject image into the last user message
-                if msg["role"] == "user" and msg is not m:
-                    user_messages.append(msg)
-                else:
-                    user_messages.append(msg)
-
-        # Replace last user message content with multimodal blocks
-        last_user = user_messages[-1]
-        last_user["content"] = [
-            {
-                "type": "image",
-                "source": {
-                    "type": "base64",
-                    "media_type": media_type,
-                    "data": image_data,
-                },
-            },
-            {"type": "text", "text": last_user["content"]},
-        ]
-
-        response = self.client.messages.create(
-            model=self.model,
-            max_tokens=4096,
-            system=system_msg,
-            messages=user_messages,
-        )
-        return response.content[0].text
-
-
-class OpenAIBackend(LLMBackend):
-    """Generate CadQuery code using OpenAI GPT-4o."""
-
-    def __init__(self, model: str = "gpt-4o", api_key: Optional[str] = None):
-        import openai
-
-        self.client = openai.OpenAI(api_key=api_key or os.environ.get("OPENAI_API_KEY"))
-        self.model = model
-
-    def generate(self, messages: list[dict]) -> str:
-        response = self.client.chat.completions.create(
-            model=self.model,
-            messages=messages,
-            max_tokens=4096,
-            temperature=0.2,
-        )
-        return response.choices[0].message.content
-
-    def generate_with_image(self, messages: list[dict], image_path: str | Path) -> str:
-        image_path = Path(image_path)
-        media_type = mimetypes.guess_type(str(image_path))[0] or "image/png"
-        image_data = base64.b64encode(image_path.read_bytes()).decode("utf-8")
-        data_url = f"data:{media_type};base64,{image_data}"
-
-        # Copy messages, replace last user message with multimodal content
-        patched = [dict(m) for m in messages]
-        last_user = patched[-1]
-        last_user["content"] = [
-            {"type": "image_url", "image_url": {"url": data_url}},
-            {"type": "text", "text": last_user["content"]},
-        ]
-
-        response = self.client.chat.completions.create(
-            model=self.model,
-            messages=patched,
-            max_tokens=4096,
-            temperature=0.2,
-        )
-        return response.choices[0].message.content
-
-
-class GeminiBackend(LLMBackend):
-    """Generate CadQuery code using Google Gemini (free tier available)."""
-
-    def __init__(self, model: str = "gemini-2.5-flash", api_key: Optional[str] = None):
-        from google import genai
-
-        self.client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY"))
-        self.model = model
-
-    def generate(self, messages: list[dict]) -> str:
-        # Convert messages to Gemini format: system instruction + contents
-        system_msg = ""
-        contents = []
-        for m in messages:
-            if m["role"] == "system":
-                system_msg = m["content"]
-            elif m["role"] == "user":
-                contents.append({"role": "user", "parts": [{"text": m["content"]}]})
-            elif m["role"] == "assistant":
-                contents.append({"role": "model", "parts": [{"text": m["content"]}]})
-
-        from google.genai import types
-
-        response = self.client.models.generate_content(
-            model=self.model,
-            contents=contents,
-            config=types.GenerateContentConfig(
-                system_instruction=system_msg,
-                max_output_tokens=4096,
-                temperature=0.2,
-            ),
-        )
-        return response.text
-
-    def generate_with_image(self, messages: list[dict], image_path: str | Path) -> str:
-        from google.genai import types
-
-        image_path = Path(image_path)
-        image_data = image_path.read_bytes()
-        media_type = mimetypes.guess_type(str(image_path))[0] or "image/png"
-
-        system_msg = ""
-        contents = []
-        for m in messages:
-            if m["role"] == "system":
-                system_msg = m["content"]
-            elif m["role"] == "user":
-                contents.append({"role": "user", "parts": [{"text": m["content"]}]})
-            elif m["role"] == "assistant":
-                contents.append({"role": "model", "parts": [{"text": m["content"]}]})
-
-        # Add image to the last user message
-        if contents and contents[-1]["role"] == "user":
-            contents[-1]["parts"].insert(0, {
-                "inline_data": {"mime_type": media_type, "data": image_data}
-            })
-
-        response = self.client.models.generate_content(
-            model=self.model,
-            contents=contents,
-            config=types.GenerateContentConfig(
-                system_instruction=system_msg,
-                max_output_tokens=4096,
-                temperature=0.2,
-            ),
-        )
-        return response.text
-
-
-class MockBackend(LLMBackend):
-    """
-    Mock backend that dynamically generates CadQuery code from any prompt.
-    Parses dimensions, shape type, and features from the text, then assembles
-    parametric code. No API key required.
-    """
-
-    # Word-to-number mapping for natural language counts
-    _WORD_NUMS = {
-        "one": 1,
-        "two": 2,
-        "three": 3,
-        "four": 4,
-        "five": 5,
-        "six": 6,
-        "seven": 7,
-        "eight": 8,
-        "nine": 9,
-        "ten": 10,
-        "twelve": 12,
-        "sixteen": 16,
-        "twenty": 20,
-    }
-
-    # Metric thread clearance hole diameters
-    _THREAD_CLEARANCE = {
-        "m2": 2.4,
-        "m3": 3.4,
-        "m4": 4.5,
-        "m5": 5.5,
-        "m6": 6.6,
-        "m8": 9.0,
-        "m10": 11.0,
-        "m12": 13.5,
-    }
-
-    # Shape detection patterns → base shape key
-    _SHAPE_PATTERNS = {
-        "cylinder": [
-            "cylinder",
-            "rod",
-            "shaft",
-            "axle",
-            "spacer",
-            "washer",
-            "bushing",
-            "sleeve",
-            "tube",
-            "pipe",
-            "dowel",
-            "pin",
-        ],
-        "plate": [
-            "plate",
-            "bracket",
-            "mount",
-            "flange",
-            "baseplate",
-            "panel",
-            "shim",
-            "cover",
-            "lid",
-        ],
-        "box": [
-            "box",
-            "block",
-            "enclosure",
-            "housing",
-            "case",
-            "cube",
-            "container",
-            "shell",
-        ],
-        "l_bracket": [
-            "l-bracket",
-            "l bracket",
-            "angle bracket",
-            "corner bracket",
-            "l-shaped",
-        ],
-    }
-
-    # Feature detection keywords
-    _FEATURE_KEYWORDS = {
-        "holes": ["hole", "holes", "bolt", "bolts", "screw", "screws", "bore", "bores"],
-        "pocket": ["pocket", "recess", "cavity", "cutout", "mortise"],
-        "slot": ["slot", "slots", "groove", "channel", "keyway"],
-        "fillet": ["fillet", "fillets", "round", "rounded"],
-        "chamfer": ["chamfer", "chamfers", "bevel", "beveled"],
-        "through_hole": ["through hole", "through-hole", "thru hole", "thru-hole"],
-        "counterbore": ["counterbore", "counterbored", "cbore"],
-        "fins": ["fin", "fins", "cooling", "heatsink", "heat sink", "radiator"],
-        "ribs": ["rib", "ribs", "stiffener", "stiffeners", "web"],
-        "boss": ["boss", "bosses", "standoff", "standoffs", "pillar"],
-    }
-
-    def _parse_prompt(self, text: str) -> dict:
-        """Extract dimensions, shape, and features from natural language."""
-        lower = text.lower()
-
-        # Extract all numbers with optional units
-        raw_nums = re.findall(r"(\d+\.?\d*)\s*(?:mm|cm|m\b)?", lower)
-        dimensions = [float(n) for n in raw_nums if 0.1 < float(n) < 2000]
-
-        # Detect metric thread sizes (M3, M6, etc.)
-        thread_match = re.search(r"\bm(\d+)\b", lower)
-        hole_dia = None
-        if thread_match:
-            key = f"m{thread_match.group(1)}"
-            hole_dia = self._THREAD_CLEARANCE.get(
-                key, float(thread_match.group(1)) * 1.1
-            )
-
-        # Detect hole diameter from "Xmm hole"
-        hole_dim_match = re.search(
-            r"(\d+\.?\d*)\s*mm\s*(?:hole|bore|holes|bores)", lower
-        )
-        if hole_dim_match and not hole_dia:
-            hole_dia = float(hole_dim_match.group(1))
-
-        # Detect count (numeric or word)
-        count = None
-        count_match = re.search(
-            r"(\d+)\s*(?:hole|bolt|screw|bore|fin|rib|slot|boss)", lower
-        )
-        if count_match:
-            count = int(count_match.group(1))
-        else:
-            for word, num in self._WORD_NUMS.items():
-                if re.search(rf"\b{word}\b.*(?:hole|bolt|screw|bore|fin|slot)", lower):
-                    count = num
-                    break
-
-        # Detect base shape
-        shape = "box"
-        for shape_key, keywords in self._SHAPE_PATTERNS.items():
-            if any(kw in lower for kw in keywords):
-                shape = shape_key
-                break
-
-        # Detect features
-        features = set()
-        for feat, keywords in self._FEATURE_KEYWORDS.items():
-            if any(kw in lower for kw in keywords):
-                features.add(feat)
-
-        # If holes mentioned but no specific feature, add generic holes
-        if (
-            any(w in lower for w in ["hole", "holes", "bolt", "screw"])
-            and "holes" not in features
-        ):
-            features.add("holes")
-
-        return {
-            "dimensions": dimensions,
-            "shape": shape,
-            "features": features,
-            "hole_dia": hole_dia or 5.5,
-            "count": count or 4,
-            "prompt": text,
-        }
-
-    def _generate_code(self, p: dict) -> str:
-        """Build CadQuery code from parsed parameters."""
-        dims = p["dimensions"]
-        shape = p["shape"]
-        features = p["features"]
-        prompt = p["prompt"]
-
-        lines = ["import cadquery as cq"]
-        if shape == "cylinder" and "fins" in features:
-            lines.append("import math")
-        lines.append(f"")
-        lines.append(f"# Generated from: {prompt}")
-
-        if shape == "cylinder":
-            radius = dims[0] / 2 if dims else 15.0
-            height = dims[1] if len(dims) > 1 else radius * 2
-            lines.append(f"# Cylinder: radius={radius}mm, height={height}mm")
-            lines.append(f"result = (")
-            lines.append(f"    cq.Workplane('XY')")
-            lines.append(f"    .cylinder({height}, {radius})")
-
-            if "holes" in features or "through_hole" in features:
-                lines.append(f"    .faces('>Z').workplane()")
-                lines.append(f"    .hole({p['hole_dia']})")
-
-            if "chamfer" in features or "fillet" not in features:
-                lines.append(f"    .edges('>Z or <Z').chamfer(0.5)")
-
-            if "fillet" in features:
-                lines.append(f"    .edges('>Z or <Z').fillet(1.0)")
-
-            lines.append(f")")
-
-            if "fins" in features:
-                n_fins = p["count"] if p["count"] > 4 else 8
-                fin_h = max(height * 0.8, 5)
-                fin_w = 1.5
-                lines.append(f"")
-                lines.append(f"# Add {n_fins} cooling fins")
-                lines.append(f"for i in range({n_fins}):")
-                lines.append(f"    angle = i * 360 / {n_fins}")
-                lines.append(f"    rad = math.radians(angle)")
-                lines.append(f"    fx = {radius + 3} * math.cos(rad)")
-                lines.append(f"    fy = {radius + 3} * math.sin(rad)")
-                lines.append(f"    fin = (")
-                lines.append(f"        cq.Workplane('XY')")
-                lines.append(
-                    f"        .transformed(offset=(fx, fy, 0), rotate=(0, 0, angle))"
-                )
-                lines.append(f"        .rect({fin_w}, {radius * 0.6})")
-                lines.append(f"        .extrude({fin_h})")
-                lines.append(f"    )")
-                lines.append(f"    result = result.union(fin)")
-
-        elif shape == "plate":
-            w = dims[0] if dims else 80.0
-            h = dims[1] if len(dims) > 1 else w * 0.6
-            t = dims[2] if len(dims) > 2 else 5.0
-            lines.append(f"# Plate: {w}x{h}x{t}mm")
-            lines.append(f"result = (")
-            lines.append(f"    cq.Workplane('XY')")
-            lines.append(f"    .box({w}, {h}, {t})")
-
-            if "holes" in features or "through_hole" in features:
-                n = p["count"]
-                dia = p["hole_dia"]
-                # Distribute holes in a grid or circle
-                if "flange" in p["prompt"].lower() or n >= 6:
-                    # Bolt circle pattern
-                    r = min(w, h) * 0.35
-                    lines.append(f"    .faces('>Z').workplane()")
-                    lines.append(f"    .polarArray({r}, 0, 360, {n})")
-                    lines.append(f"    .hole({dia})")
-                    if "bore" in p["prompt"].lower() or "flange" in p["prompt"].lower():
-                        lines.append(f"    .faces('>Z').workplane()")
-                        lines.append(f"    .hole({dia * 3})  # Center bore")
-                else:
-                    # Rectangular pattern
-                    ox = w * 0.35
-                    oy = h * 0.35
-                    pts = []
-                    if n == 1:
-                        pts = [(0, 0)]
-                    elif n == 2:
-                        pts = [(-ox, 0), (ox, 0)]
-                    elif n == 4:
-                        pts = [(-ox, -oy), (-ox, oy), (ox, -oy), (ox, oy)]
-                    else:
-                        pts = [(-ox, -oy), (-ox, oy), (ox, -oy), (ox, oy)]
-                    lines.append(f"    .faces('>Z').workplane()")
-                    lines.append(f"    .pushPoints({pts})")
-                    lines.append(f"    .hole({dia})")
-
-            if "pocket" in features:
-                pw = w * 0.4
-                ph = h * 0.35
-                pd = t * 0.6
-                lines.append(f"    .faces('>Z').workplane()")
-                lines.append(f"    .rect({pw}, {ph})")
-                lines.append(f"    .cutBlind(-{pd})  # Central pocket")
-
-            if "slot" in features:
-                sl = w * 0.35
-                sw = max(t * 0.8, 4)
-                lines.append(f"    .faces('>Z').workplane()")
-                lines.append(f"    .slot2D({sl}, {sw}).cutBlind(-{t})")
-
-            if "fillet" in features:
-                lines.append(f"    .edges('|Z').fillet({max(t * 0.4, 1.5)})")
-            else:
-                lines.append(f"    .edges('>Z').chamfer(0.5)")
-
-            lines.append(f")")
-
-        elif shape == "l_bracket":
-            arm = dims[0] if dims else 50.0
-            width = dims[1] if len(dims) > 1 else 20.0
-            t = dims[2] if len(dims) > 2 else 4.0
-            lines.append(f"# L-bracket: {arm}mm arms, {width}mm wide, {t}mm thick")
-            lines.append(f"result = (")
-            lines.append(f"    cq.Workplane('XZ')")
-            lines.append(f"    .moveTo(0, 0)")
-            lines.append(f"    .lineTo({arm}, 0)")
-            lines.append(f"    .lineTo({arm}, {t})")
-            lines.append(f"    .lineTo({t}, {t})")
-            lines.append(f"    .lineTo({t}, {arm})")
-            lines.append(f"    .lineTo(0, {arm})")
-            lines.append(f"    .close()")
-            lines.append(f"    .extrude({width})")
-            lines.append(f"    .edges('|Y').fillet({max(t * 0.5, 1.5)})")
-
-            if "holes" in features:
-                lines.append(
-                    f"    .faces('>Z').workplane(centerOption='CenterOfBoundBox')"
-                )
-                lines.append(f"    .center({arm * 0.5}, 0)")
-                lines.append(f"    .hole({p['hole_dia']})")
-                lines.append(
-                    f"    .faces('>X').workplane(centerOption='CenterOfBoundBox')"
-                )
-                lines.append(f"    .center(0, {arm * 0.5})")
-                lines.append(f"    .hole({p['hole_dia']})")
-
-            lines.append(f"    .edges().chamfer(0.5)")
-            lines.append(f")")
-
-        else:  # box / enclosure / housing
-            w = dims[0] if dims else 60.0
-            h = dims[1] if len(dims) > 1 else w * 0.65
-            d = dims[2] if len(dims) > 2 else 20.0
-            lines.append(f"# Box: {w}x{h}x{d}mm")
-            lines.append(f"result = (")
-            lines.append(f"    cq.Workplane('XY')")
-            lines.append(f"    .box({w}, {h}, {d})")
-
-            if "holes" in features or "through_hole" in features:
-                ox = w * 0.35
-                oy = h * 0.35
-                pts = [(-ox, -oy), (-ox, oy), (ox, -oy), (ox, oy)]
-                lines.append(f"    .faces('>Z').workplane()")
-                lines.append(f"    .pushPoints({pts})")
-                lines.append(f"    .hole({p['hole_dia']})")
-
-            if "pocket" in features:
-                pw = w * 0.5
-                ph = h * 0.4
-                pd = d * 0.4
-                lines.append(f"    .faces('>Z').workplane()")
-                lines.append(f"    .rect({pw}, {ph})")
-                lines.append(f"    .cutBlind(-{pd})")
-
-            if "slot" in features:
-                sl = w * 0.4
-                sw = 6
-                lines.append(f"    .faces('>Z').workplane()")
-                lines.append(f"    .slot2D({sl}, {sw}).cutBlind(-{d})")
-
-            if "boss" in features:
-                n = min(p["count"], 4)
-                bx = w * 0.3
-                by = h * 0.3
-                boss_pts = [(-bx, -by), (-bx, by), (bx, -by), (bx, by)][:n]
-                lines.append(f"    .faces('>Z').workplane()")
-                lines.append(f"    .pushPoints({boss_pts})")
-                lines.append(f"    .circle(4).extrude(6)  # Mounting bosses")
-
-            if "ribs" in features:
-                n_ribs = p["count"] if p["count"] <= 8 else 4
-                spacing = w / (n_ribs + 1)
-                lines.append(f"    .faces('>Z').workplane()")
-                for i in range(n_ribs):
-                    rx = -w / 2 + spacing * (i + 1)
-                    lines.append(f"    .center({rx if i == 0 else spacing}, 0)")
-                    lines.append(f"    .rect(2, {h * 0.8}).extrude({d * 0.3})")
-
-            if "fillet" in features:
-                lines.append(f"    .edges('|Z').fillet({min(d * 0.2, 3)})")
-            elif "chamfer" in features:
-                lines.append(f"    .edges('>Z').chamfer(1.0)")
-            else:
-                lines.append(f"    .edges('>Z').chamfer(0.5)")
-
-            lines.append(f")")
-
-        return "\n".join(lines) + "\n"
-
-    # Curated hero responses for specific prompts
-    _CURATED = {
-        "gear": """\
-import cadquery as cq
-import math
-
-# Simple spur gear approximation: 20 teeth, module 2, 10mm thick
-module = 2
-teeth = 20
-pitch_radius = module * teeth / 2
-outer_radius = pitch_radius + module
-tooth_angle = 360 / teeth
-
-result = (
-    cq.Workplane("XY")
-    .cylinder(10, outer_radius)
-    .faces(">Z").workplane()
-    .hole(12)
-)
-
-for i in range(teeth):
-    angle = i * tooth_angle
-    rad = math.radians(angle)
-    gap_x = pitch_radius * math.cos(rad)
-    gap_y = pitch_radius * math.sin(rad)
-    cutter = (
-        cq.Workplane("XY")
-        .transformed(offset=(gap_x, gap_y, 0), rotate=(0, 0, angle))
-        .rect(module * 0.8, module * 2.5)
-        .extrude(12)
-    )
-    result = result.cut(cutter)
-
-result = result.edges(">Z or <Z").chamfer(0.3)
-""",
-    }
-
-    def generate(self, messages: list[dict]) -> str:
-        user_msg = messages[-1]["content"]
-        lower = user_msg.lower()
-
-        # Check curated responses first
-        for key, code in self._CURATED.items():
-            if key in lower:
-                return code
-
-        # Dynamic generation for everything else
-        params = self._parse_prompt(user_msg)
-        return self._generate_code(params)
-
-
-class NeuralCADBackend(LLMBackend):
-    """
-    Neural CAD pipeline backend.
-
-    Runs trained models locally:
-      Text/Image → CLIP encoder → contrastive latent
-        → Diffusion prior → latent
-        → Transformer decoder → CAD command sequence
-        → OpenCascade kernel → B-rep solid
-
-    Unlike LLM backends, this does not generate CadQuery code strings.
-    Instead it produces CAD command sequences decoded directly into geometry.
-    """
-
-    def __init__(
-        self,
-        model_dir: str | Path = "./models",
-        device: str = "cuda",
-        clip_model: str = "clip_encoder.pt",
-        prior_model: str = "diffusion_prior.pt",
-        decoder_model: str = "transformer_decoder.pt",
-    ):
-        self.model_dir = Path(model_dir)
-        self.device = device
-        self.clip_encoder = None
-        self.diffusion_prior = None
-        self.transformer_decoder = None
-        self._model_config = {
-            "clip": clip_model,
-            "prior": prior_model,
-            "decoder": decoder_model,
-        }
-
-    def load_models(self):
-        """Load all model weights from disk. Call once before inference."""
-        raise NotImplementedError(
-            f"Model loading not yet implemented. "
-            f"Expected model files in: {self.model_dir}"
-        )
-
-    def encode_text(self, text: str):
-        """Encode text prompt to CLIP latent vector."""
-        raise NotImplementedError("CLIP text encoder not yet implemented")
-
-    def encode_image(self, image_path: str | Path):
-        """Encode image (photo/sketch) to CLIP latent vector."""
-        raise NotImplementedError("CLIP image encoder not yet implemented")
-
-    def run_diffusion_prior(self, clip_embedding):
-        """Map CLIP embedding to CAD latent via diffusion prior."""
-        raise NotImplementedError("Diffusion prior not yet implemented")
-
-    def decode_to_cad_sequence(self, latent):
-        """Decode latent to CAD command sequence."""
-        raise NotImplementedError("Transformer decoder not yet implemented")
-
-    def cad_sequence_to_solid(self, cad_commands: list[dict]):
-        """Execute CAD command sequence through OpenCascade kernel → B-rep solid."""
-        raise NotImplementedError("CAD kernel execution not yet implemented")
-
-    def generate(self, messages: list[dict]) -> str:
-        """
-        LLMBackend-compatible interface.
-
-        Extracts the text prompt from messages, runs the full neural pipeline,
-        and returns CadQuery-equivalent code as a string for compatibility
-        with the existing execution/validation/export pipeline.
-        """
-        user_msg = messages[-1]["content"]
-
-        clip_emb = self.encode_text(user_msg)
-        latent = self.run_diffusion_prior(clip_emb)
-        cad_commands = self.decode_to_cad_sequence(latent)
-        return self._cad_commands_to_code(cad_commands)
-
-    def generate_from_image(self, image_path: str | Path, text_hint: str = "") -> str:
-        """
-        Image-conditioned generation (not available on LLM backends).
-
-        Args:
-            image_path: Path to photo or sketch of the desired part.
-            text_hint: Optional text to guide generation alongside the image.
-
-        Returns:
-            CadQuery code string for pipeline compatibility.
-        """
-        img_emb = self.encode_image(image_path)
-        if text_hint:
-            txt_emb = self.encode_text(text_hint)
-            # Fuse text + image embeddings (strategy TBD — average, concat, cross-attn)
-            clip_emb = (img_emb + txt_emb) / 2  # placeholder fusion
-        else:
-            clip_emb = img_emb
-
-        latent = self.run_diffusion_prior(clip_emb)
-        cad_commands = self.decode_to_cad_sequence(latent)
-        return self._cad_commands_to_code(cad_commands)
-
-    def _cad_commands_to_code(self, cad_commands: list[dict]) -> str:
-        """Convert internal CAD command sequence to CadQuery Python code string."""
-        raise NotImplementedError(
-            "CAD command → CadQuery code serializer not yet implemented"
-        )
-
-
-# ── Pipeline ──────────────────────────────────────────────────────────────
-
-
-@dataclass
-class PipelineResult:
-    prompt: str
-    generated_code: str
-    execution: ExecutionResult
-    validation: Optional[CNCValidationResult] = None
-    exported_files: dict[str, Path] = None
-    retry_count: int = 0
-
-    def summary(self) -> str:
-        lines = [
-            "=" * 60,
-            "TEXT-TO-CNC PIPELINE RESULT",
-            "=" * 60,
-            f"Prompt: {self.prompt}",
-            f"Retries: {self.retry_count}",
-            "",
-            "── Execution ──",
-            self.execution.summary(),
-            "",
-        ]
-        if self.validation:
-            lines += ["── CNC Validation ──", self.validation.summary(), ""]
-        if self.exported_files:
-            lines += ["── Exported Files ──"]
-            for fmt, path in self.exported_files.items():
-                lines.append(f"  {fmt.upper()}: {path}")
-        lines.append("=" * 60)
-        return "\n".join(lines)
-
-
-def run_pipeline(
-    prompt: str,
-    backend: Optional[LLMBackend] = None,
-    output_dir: str | Path = "./output",
-    max_retries: int = 2,
-    export: bool = True,
-    validate: bool = True,
-    part_name: Optional[str] = None,
-) -> PipelineResult:
-    """
-    Run the full text-to-CNC pipeline.
-
-    Args:
-        prompt: Natural language description of the part.
-        backend: LLM backend to use. Defaults to MockBackend.
-        output_dir: Directory for exported files.
-        max_retries: Number of retry attempts if code execution fails.
-        export: Whether to export STEP/STL files.
-        validate: Whether to run CNC validation.
-        part_name: Name for the part (used in filenames).
-
-    Returns:
-        PipelineResult with all pipeline outputs.
-    """
-    if backend is None:
-        backend = MockBackend()
-
-    output_dir = Path(output_dir)
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    if part_name is None:
-        # Generate a filename-safe name from the prompt
-        part_name = prompt[:40].strip().replace(" ", "_").lower()
-        part_name = "".join(c for c in part_name if c.isalnum() or c == "_")
-
-    # Stage 1: Generate code
-    messages = build_messages(prompt)
-    generated_code = backend.generate(messages)
-
-    # Stage 2: Execute with retry loop
-    execution = execute_cadquery(generated_code)
-    retry_count = 0
-
-    while not execution.success and retry_count < max_retries:
-        retry_count += 1
-        print(f"  Retry {retry_count}/{max_retries}: fixing error...")
-
-        # Feed the error back to the LLM for self-correction
-        error_feedback = (
-            f"The previous code failed with this error:\n"
-            f"```\n{execution.error}\n```\n\n"
-            f"Please fix the code and return only the corrected Python code. "
-            f"Original request: {prompt}"
-        )
-        messages_retry = build_messages(error_feedback)
-        generated_code = backend.generate(messages_retry)
-        execution = execute_cadquery(generated_code)
-
-    # Stage 3: Validate for CNC
-    validation = None
-    if execution.success and validate:
-        validation = validate_for_cnc(execution.result, part_name=part_name)
-
-    # Stage 4: Export
-    exported_files = {}
-    if execution.success and export:
-        base_path = output_dir / part_name
-        try:
-            exported_files = export_all(execution.result, base_path)
-        except Exception as e:
-            print(f"  Export warning: {e}")
-
-    return PipelineResult(
-        prompt=prompt,
-        generated_code=generated_code,
-        execution=execution,
-        validation=validation,
-        exported_files=exported_files or {},
-        retry_count=retry_count,
-    )
-
-
-# ── CLI Entry Point ───────────────────────────────────────────────────────
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Text-to-CNC Model Generator")
-    parser.add_argument("prompt", nargs="?", default=None, help="Part description")
-    parser.add_argument(
-        "--backend", choices=["mock", "anthropic", "openai", "gemini", "neural"], default="mock"
-    )
-    parser.add_argument("--output-dir", default="./output")
-    parser.add_argument("--retries", type=int, default=2)
-    parser.add_argument("--name", default=None, help="Part name for file output")
-    parser.add_argument("--no-validate", action="store_true")
-    parser.add_argument("--no-export", action="store_true")
-    args = parser.parse_args()
-
-    if args.prompt is None:
-        args.prompt = "A simple mounting bracket with two M5 bolt holes"
-
-    # Select backend
-    if args.backend == "neural":
-        backend = NeuralCADBackend()
-    elif args.backend == "anthropic":
-        backend = AnthropicBackend()
-    elif args.backend == "openai":
-        backend = OpenAIBackend()
-    elif args.backend == "gemini":
-        backend = GeminiBackend()
-    else:
-        backend = MockBackend()
-
-    print(f"Generating CNC model for: '{args.prompt}'")
-    print(f"Backend: {args.backend}")
-    print()
-
-    result = run_pipeline(
-        prompt=args.prompt,
-        backend=backend,
-        output_dir=args.output_dir,
-        max_retries=args.retries,
-        export=not args.no_export,
-        validate=not args.no_validate,
-        part_name=args.name,
-    )
-
-    print(result.summary())
-
-    if result.execution.success:
-        print("\nGenerated Code:")
-        print("-" * 40)
-        print(result.generated_code)

pyproject.toml

@@ -11,7 +11,6 @@ dependencies = [
     "anthropic>=0.25.0",
     "openai>=1.30.0",
     "google-genai>=1.0.0",
-    "crewai>=0.80.0",
     "mcp>=1.0.0",
     "fastapi>=0.110.0",
     "uvicorn>=0.29.0",

web_server.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-"""
-NeuralCAD Web Demo Server
-=========================
-FastAPI server that proxies REST requests to the MCP CAD server (SSE transport)
-and serves the web frontend.
-
-Usage:
-    # Start MCP server first:
-    python mcp_server.py --transport sse --port 8000
-
-    # Then start web server:
-    python web_server.py
-
-    # Or auto-launch MCP server:
-    python web_server.py --start-mcp
-
-    # Open http://localhost:5000
-"""
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-import time
-from contextlib import asynccontextmanager
-from pathlib import Path
-
-from fastapi import FastAPI, File, Form, UploadFile
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
-
-from mcp import ClientSession
-from mcp.client.sse import sse_client
-
-# ── Config ───────────────────────────────────────────────────────────────
-
-MCP_SERVER_URL = os.environ.get("MCP_SERVER_URL", "http://localhost:8000/sse")
-OUTPUT_DIR = Path(__file__).parent / "output"
-WEB_DIR = Path(__file__).parent / "web"
-PORT = int(os.environ.get("WEB_PORT", "5000"))
-
-# ── MCP Client Management ───────────────────────────────────────────────
-
-_mcp_process = None
-
-
-async def call_mcp_tool(tool_name: str, arguments: dict) -> dict:
-    """Connect to MCP server, call a tool, return parsed JSON result."""
-    async with sse_client(url=MCP_SERVER_URL) as streams:
-        async with ClientSession(*streams) as session:
-            await session.initialize()
-            result = await session.call_tool(name=tool_name, arguments=arguments)
-            if result.content:
-                return json.loads(result.content[0].text)
-            return {"error": "Empty response from MCP server"}
-
-
-async def read_mcp_resource(uri: str) -> str:
-    """Connect to MCP server and read a resource."""
-    async with sse_client(url=MCP_SERVER_URL) as streams:
-        async with ClientSession(*streams) as session:
-            await session.initialize()
-            result = await session.read_resource(uri=uri)
-            if result.contents:
-                return result.contents[0].text
-            return "{}"
-
-
-def start_mcp_server(port: int = 8000):
-    """Launch mcp_server.py as a subprocess with SSE transport."""
-    global _mcp_process
-    mcp_script = Path(__file__).parent / "mcp_server.py"
-    _mcp_process = subprocess.Popen(
-        [sys.executable, str(mcp_script), "--transport", "sse", "--port", str(port)],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
-    # Give it a moment to start
-    time.sleep(2)
-    if _mcp_process.poll() is not None:
-        stderr = _mcp_process.stderr.read().decode() if _mcp_process.stderr else ""
-        raise RuntimeError(f"MCP server failed to start: {stderr}")
-    print(f"  MCP server started (PID {_mcp_process.pid}) on port {port}")
-
-
-# ── FastAPI App ──────────────────────────────────────────────────────────
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    OUTPUT_DIR.mkdir(exist_ok=True)
-    yield
-    global _mcp_process
-    if _mcp_process:
-        _mcp_process.terminate()
-        _mcp_process.wait()
-
-
-app = FastAPI(title="NeuralCAD Web Demo", lifespan=lifespan)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-# ── Routes ───────────────────────────────────────────────────────────────
-
-@app.get("/", response_class=HTMLResponse)
-async def index():
-    index_file = WEB_DIR / "index.html"
-    return HTMLResponse(index_file.read_text())
-
-
-@app.post("/api/generate")
-async def generate(body: dict):
-    result = await call_mcp_tool("generate_cnc_model", {
-        "prompt": body.get("prompt", ""),
-        "part_name": body.get("part_name", ""),
-        "backend": body.get("backend", "mock"),
-        "max_retries": body.get("max_retries", 2),
-    })
-    return JSONResponse(result)
-
-
-@app.post("/api/generate-image")
-async def generate_image(
-    image: UploadFile = File(...),
-    text_hint: str = Form(""),
-    part_name: str = Form(""),
-    backend: str = Form("anthropic"),
-):
-    # Save uploaded image to temp file
-    suffix = Path(image.filename or "upload.png").suffix
-    with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
-        tmp.write(await image.read())
-        tmp_path = tmp.name
-
-    try:
-        result = await call_mcp_tool("generate_from_image", {
-            "image_path": tmp_path,
-            "text_hint": text_hint,
-            "part_name": part_name,
-            "backend": backend,
-        })
-        return JSONResponse(result)
-    finally:
-        os.unlink(tmp_path)
-
-
-@app.post("/api/validate")
-async def validate(body: dict):
-    result = await call_mcp_tool("validate_cnc_model", {
-        "cadquery_code": body.get("code", ""),
-        "part_name": body.get("part_name", "Part"),
-    })
-    return JSONResponse(result)
-
-
-@app.get("/api/models")
-async def list_models():
-    result = await call_mcp_tool("list_models", {
-        "output_dir": str(OUTPUT_DIR),
-    })
-    return JSONResponse(result)
-
-
-@app.get("/api/models/{name}.stl")
-async def get_stl(name: str):
-    path = OUTPUT_DIR / f"{name}.stl"
-    if not path.exists():
-        return JSONResponse({"error": f"STL not found: {name}"}, status_code=404)
-    return FileResponse(path, media_type="model/stl", filename=f"{name}.stl")
-
-
-@app.get("/api/models/{name}.step")
-async def get_step(name: str):
-    path = OUTPUT_DIR / f"{name}.step"
-    if not path.exists():
-        return JSONResponse({"error": f"STEP not found: {name}"}, status_code=404)
-    return FileResponse(path, media_type="application/step", filename=f"{name}.step")
-
-
-@app.get("/api/capabilities")
-async def capabilities():
-    try:
-        text = await read_mcp_resource("text-to-cnc://capabilities")
-        return JSONResponse(json.loads(text))
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=502)
-
-
-# ── Entry Point ──────────────────────────────────────────────────────────
-
-if __name__ == "__main__":
-    import argparse
-    import uvicorn
-
-    parser = argparse.ArgumentParser(description="NeuralCAD Web Demo Server")
-    parser.add_argument("--port", type=int, default=PORT, help="Web server port (default: 5000)")
-    parser.add_argument("--host", default="0.0.0.0", help="Bind host (default: 0.0.0.0)")
-    parser.add_argument(
-        "--start-mcp", action="store_true",
-        help="Auto-launch MCP server as subprocess before starting web server"
-    )
-    parser.add_argument("--mcp-port", type=int, default=8000, help="MCP server port (default: 8000)")
-    args = parser.parse_args()
-
-    if args.start_mcp:
-        MCP_SERVER_URL = f"http://localhost:{args.mcp_port}/sse"
-        print(f"Starting MCP CAD server on port {args.mcp_port}...")
-        start_mcp_server(args.mcp_port)
-
-    print(f"Starting NeuralCAD Web Demo on http://localhost:{args.port}")
-    print(f"MCP server: {MCP_SERVER_URL}")
-    uvicorn.run(app, host=args.host, port=args.port)