NaturalCAD: Add LLM via HF Inference, GLB export, and update docs

apps/cad-worker/main.py

@@ -0,0 +1,222 @@
+"""
+NaturalCAD Modal Function
+Takes user prompt, generates build123d code, runs it, returns STL.
+"""
+
+import modal
+from pathlib import Path
+import tempfile
+
+app = modal.App("naturalcad")
+
+# Base image with Python 3.10 and graphics libraries
+image = (
+    modal.Image.from_registry("python:3.10-slim")
+    .apt_install(
+        "libgl1",
+        "libglib2.0-0", 
+        "libxrender1",
+        "libxext6",
+        "libxkbcommon0"
+    )
+    .pip_install("build123d==0.10.0", "trimesh", "huggingface_hub", "httpx")
+)
+
+
+def _upload_to_supabase(storage_key: str, file_data: bytes, content_type: str = "application/octet-stream") -> str:
+    import httpx
+    import urllib.parse
+    import os
+    
+    url = os.environ.get("SUPABASE_URL", "").rstrip("/")
+    key = os.environ.get("SUPABASE_SERVICE_ROLE_KEY", "")
+    bucket = os.environ.get("SUPABASE_BUCKET", "naturalCAD-artifacts")
+    
+    if not url or not key:
+        raise ValueError("Missing Supabase credentials in environment")
+        
+    encoded_key = urllib.parse.quote(storage_key, safe="/")
+    endpoint = f"{url}/storage/v1/object/{bucket}/{encoded_key}"
+    
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "Content-Type": content_type,
+        "x-upsert": "true"
+    }
+    
+    with httpx.Client() as client:
+        resp = client.post(endpoint, content=file_data, headers=headers)
+        if resp.status_code >= 400:
+            raise Exception(f"Supabase upload failed {resp.status_code}: {resp.text}")
+            
+    return f"{url}/storage/v1/object/public/{bucket}/{encoded_key}"
+
+
+@app.function(
+    image=image, 
+    gpu="T4", 
+    timeout=300,
+    secrets=[
+        modal.Secret.from_name("huggingface-secret"),
+        modal.Secret.from_name("supabase-secret")
+    ]
+)
+@modal.web_endpoint(method="POST")
+def generate_cad_endpoint(prompt: str, output_format: str = "stl"):
+    return generate_cad.local(prompt, output_format)
+
+
+@app.function(
+    image=image, 
+    gpu="T4", 
+    timeout=300,
+    secrets=[
+        modal.Secret.from_name("huggingface-secret"),
+        modal.Secret.from_name("supabase-secret")
+    ]
+)
+def generate_cad(prompt: str, output_format: str = "stl"):
+    """Main function: prompt -> LLM -> code -> build123d -> Supabase STL URL"""
+    import os
+    import uuid
+    from huggingface_hub import InferenceClient
+    
+    # 1. LLM Code Generation
+    hf_token = os.environ.get("HF_TOKEN")
+    if not hf_token:
+        return {"error": "HF_TOKEN not found in environment secrets"}
+        
+    client = InferenceClient(
+        model="Qwen/Qwen2.5-Coder-32B-Instruct", 
+        token=hf_token
+    )
+    
+    system_prompt = """You are an expert Python developer for CAD code generation using the build123d library.
+Write Python code to create the 3D model requested by the user.
+
+Rules:
+1. ONLY return valid Python code. No markdown formatting, no explanations.
+2. ALWAYS import build123d using: `from build123d import *`
+3. ALWAYS store the final resulting Shape/Part in a variable named `result`.
+4. Use standard primitives like Box, Cylinder, Rectangle, Circle, etc.
+5. Make sure the code is simple, correct and uses the modern builder API (with BuildPart() as bp, etc.).
+
+Example:
+from build123d import *
+width = 60
+height = 40
+thickness = 6
+with BuildPart() as bp:
+    with BuildSketch(Plane.XY) as base:
+        Rectangle(width, height)
+    extrude(amount=thickness)
+result = bp.part
+"""
+
+    print(f"Calling LLM for prompt: {prompt}")
+    try:
+        response = client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=1024,
+            temperature=0.2,
+        )
+        generated_code = response.choices[0].message.content.strip()
+        
+        # Clean up markdown
+        if generated_code.startswith("```python"):
+            generated_code = generated_code[9:]
+        elif generated_code.startswith("```"):
+            generated_code = generated_code[3:]
+        if generated_code.endswith("```"):
+            generated_code = generated_code[:-3]
+            
+        generated_code = generated_code.strip()
+    except Exception as e:
+        return {"error": f"LLM code generation failed: {e}"}
+
+    print(f"Generated Code:\n{generated_code}")
+
+
+    # Run build123d
+    from build123d import export_stl, export_step
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        script_path = Path(tmpdir) / "script.py"
+        script_path.write_text(generated_code)
+        
+        output_file = Path(tmpdir) / f"output.{output_format}"
+        
+        # Execute
+        exec_globals = {}
+        exec(compile(generated_code, str(script_path), "exec"), exec_globals)
+        result_shape = exec_globals.get("result")
+        
+        if not result_shape:
+            return {"error": "No geometry generated"}
+        
+        # Get shape
+        shape = result_shape
+        # In newer build123d, parts don't need wrapping extracted for export
+        # We just pass the Part or Shape object directly
+        
+        # Export and upload all formats
+        urls = {}
+        run_id = uuid.uuid4().hex[:8]
+        
+        # Make STL and STEP
+        export_stl(shape, str(Path(tmpdir) / "output.stl"))
+        export_step(shape, str(Path(tmpdir) / "output.step"))
+        
+        # Make GLB preview
+        from trimesh import load_mesh
+        import trimesh.transformations as tf
+        import math
+        
+        mesh = load_mesh(str(Path(tmpdir) / "output.stl"), force="mesh")
+        # Rotate -90 degrees around X axis so Z is up in the browser
+        mesh.apply_transform(tf.rotation_matrix(-math.pi/2, [1, 0, 0]))
+        mesh.export(str(Path(tmpdir) / "output.glb"))
+        
+        for fmt in ["stl", "step", "glb"]:
+            out_file = Path(tmpdir) / f"output.{fmt}"
+            
+            if fmt == "stl":
+                content_type = "model/stl"
+            elif fmt == "step":
+                content_type = "application/octet-stream"
+            else:
+                content_type = "model/gltf-binary"
+                
+            storage_key = f"runs/{run_id}/model.{fmt}"
+            
+            print(f"Uploading {fmt} artifact to Supabase...")
+            file_bytes = out_file.read_bytes()
+            
+            try:
+                public_url = _upload_to_supabase(storage_key, file_bytes, content_type)
+                urls[fmt] = public_url
+            except Exception as e:
+                return {"error": f"Supabase upload failed for {fmt}: {e}", "code": generated_code}
+        
+        return {
+            "success": True,
+            "urls": urls,
+            "prompt": prompt,
+            "generated_code": generated_code
+        }
+
+
+@app.function(image=image)
+def health_check():
+    """Verify build123d works"""
+    from build123d import Box
+    return {"status": "ok", "build123d": "working"}
+
+
+if __name__ == "__main__":
+    # Test locally in the container
+    result = generate_cad.call("a simple bracket plate")
+    print(result)

docs/architecture-plan.md

@@ -0,0 +1,67 @@
+# NaturalCAD Architecture Plan
+
+## Current State (2026-04-12)
+
+We successfully pivoted away from a complex (and broken) Fly.io worker and Hugging Face Docker setup, replacing the backend engine entirely with **Modal**.
+
+### What's Working
+- ✅ **LLM Code Generation**: Using `Qwen/Qwen2.5-Coder-32B-Instruct` via Hugging Face Serverless Inference API inside Modal.
+- ✅ **CAD Execution Engine**: Modal spins up a `python:3.10-slim` container with proper Linux OpenGL libraries (`libgl1`, `libglib2.0-0`, etc). `build123d` runs locally on the T4 GPU container.
+- ✅ **Artifact Upload**: Modal container runs CAD, creates STL, STEP, and a browser-ready GLB using `trimesh`, and uploads directly to Supabase Storage, returning public URLs.
+- ✅ **HF Spaces UI**: Front-end UI remains on Hugging Face Spaces.
+
+### What's Deprecated
+- ❌ Fly.io backend routing and worker loops (too much complexity/overhead for MVP).
+- ❌ Hugging Face native Docker CAD execution (lacks host graphics libs for VTK).
+
+---
+
+## Target Architecture
+
+```
+┌─────────────┐
+│   User      │────▶ HF Spaces (Gradio UI)
+│  Prompt    │
+└─────────────┘
+      │
+      ▼
+┌───────────────────────────────────────┐
+│              Modal Web Endpoint        │
+│                                       │
+│ 1. Calls HF Inference API (Qwen 2.5)  │
+│ 2. LLM writes build123d Python script │
+│ 3. Executes script on Modal Container │
+│ 4. Generates STL + STEP + GLB preview │
+│ 5. Uploads files to Supabase          │
+│ 6. Returns 3 URLs back to HF Space    │
+└───────────────────────────────────────┘
+      │
+      ▼
+┌──────────────┐
+│  Supabase    │
+│  Storage     │
+└──────────────┘
+```
+
+## Services
+
+| Service | Role | Cost | Status |
+|---------|------|-----|--------|
+| **HF Spaces** | UI/Frontend | Free tier | ✅ Ready |
+| **Modal** | Web API + LLM call + CAD Execution | Pay-per-use GPU | ✅ Ready |
+| **HF Inference API**| LLM (text→code) | Free within limits | ✅ Ready |
+| **Supabase** | DB + Storage | Free tier | ✅ Ready |
+
+---
+
+## Implementation Order
+
+1. ✅ **Create Modal function** for CAD execution
+2. ✅ **Add LLM generation via HF** to the Modal container
+3. ✅ **Add Supabase Artifact Upload** returning public URL
+4. 🔲 **Deploy Modal Web Endpoint** to get a live URL
+5. 🔲 **Wire HF Spaces** to hit the Modal endpoint, parsing out the STL, STEP, and GLB urls into the Gradio UI.
+
+---
+
+*Updated: 2026-04-12*