@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/README.original.md

@@ -0,0 +1,294 @@
+# OpenSCAD MCP Server
+
+A Model Context Protocol (MCP) server that enables users to generate 3D models from text descriptions or images, with a focus on creating parametric 3D models using multi-view reconstruction and OpenSCAD.
+
+## Features
+
+- **AI Image Generation**: Generate images from text descriptions using Google Gemini or Venice.ai APIs
+- **Multi-View Image Generation**: Create multiple views of the same 3D object for reconstruction
+- **Image Approval Workflow**: Review and approve/deny generated images before reconstruction
+- **3D Reconstruction**: Convert approved multi-view images into 3D models using CUDA Multi-View Stereo
+- **Remote Processing**: Process computationally intensive tasks on remote servers within your LAN
+- **OpenSCAD Integration**: Generate parametric 3D models using OpenSCAD
+- **Parametric Export**: Export models in formats that preserve parametric properties (CSG, AMF, 3MF, SCAD)
+- **3D Printer Discovery**: Optional network printer discovery and direct printing
+
+## Architecture
+
+The server is built using the Python MCP SDK and follows a modular architecture:
+
+```
+openscad-mcp-server/
+├── src/
+│   ├── main.py                  # Main application
+│   ├── main_remote.py           # Remote CUDA MVS server
+│   ├── ai/                      # AI integrations
+│   │   ├── gemini_api.py        # Google Gemini API for image generation
+│   │   └── venice_api.py        # Venice.ai API for image generation (optional)
+│   ├── models/                  # 3D model generation
+│   │   ├── cuda_mvs.py          # CUDA Multi-View Stereo integration
+│   │   └── code_generator.py    # OpenSCAD code generation
+│   ├── workflow/                # Workflow components
+│   │   ├── image_approval.py    # Image approval mechanism
+│   │   └── multi_view_to_model_pipeline.py  # Complete pipeline
+│   ├── remote/                  # Remote processing
+│   │   ├── cuda_mvs_client.py   # Client for remote CUDA MVS processing
+│   │   ├── cuda_mvs_server.py   # Server for remote CUDA MVS processing
+│   │   ├── connection_manager.py # Remote connection management
+│   │   └── error_handling.py    # Error handling for remote processing
+│   ├── openscad_wrapper/        # OpenSCAD CLI wrapper
+│   ├── visualization/           # Preview generation and web interface
+│   ├── utils/                   # Utility functions
+│   └── printer_discovery/       # 3D printer discovery
+├── scad/                        # Generated OpenSCAD files
+├── output/                      # Output files (models, previews)
+│   ├── images/                  # Generated images
+│   ├── multi_view/              # Multi-view images
+│   ├── approved_images/         # Approved images for reconstruction
+│   └── models/                  # Generated 3D models
+├── templates/                   # Web interface templates
+└── static/                      # Static files for web interface
+```
+
+## Installation
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/jhacksman/OpenSCAD-MCP-Server.git
+   cd OpenSCAD-MCP-Server
+   ```
+
+2. Create a virtual environment:
+   ```
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. Install dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+4. Install OpenSCAD:
+   - Ubuntu/Debian: `sudo apt-get install openscad`
+   - macOS: `brew install openscad`
+   - Windows: Download from [openscad.org](https://openscad.org/downloads.html)
+
+5. Install CUDA Multi-View Stereo:
+   ```
+   git clone https://github.com/fixstars/cuda-multi-view-stereo.git
+   cd cuda-multi-view-stereo
+   mkdir build && cd build
+   cmake ..
+   make
+   ```
+
+6. Set up API keys:
+   - Create a `.env` file in the root directory
+   - Add your API keys:
+     ```
+     GEMINI_API_KEY=your-gemini-api-key
+     VENICE_API_KEY=your-venice-api-key  # Optional
+     REMOTE_CUDA_MVS_API_KEY=your-remote-api-key  # For remote processing
+     ```
+
+## Remote Processing Setup
+
+The server supports remote processing of computationally intensive tasks, particularly CUDA Multi-View Stereo reconstruction. This allows you to offload processing to more powerful machines within your LAN.
+
+### Server Setup (on the machine with CUDA GPU)
+
+1. Install CUDA Multi-View Stereo on the server machine:
+   ```
+   git clone https://github.com/fixstars/cuda-multi-view-stereo.git
+   cd cuda-multi-view-stereo
+   mkdir build && cd build
+   cmake ..
+   make
+   ```
+
+2. Start the remote CUDA MVS server:
+   ```
+   python src/main_remote.py
+   ```
+
+3. The server will automatically advertise itself on the local network using Zeroconf.
+
+### Client Configuration
+
+1. Configure remote processing in your `.env` file:
+   ```
+   REMOTE_CUDA_MVS_ENABLED=True
+   REMOTE_CUDA_MVS_USE_LAN_DISCOVERY=True
+   REMOTE_CUDA_MVS_API_KEY=your-shared-secret-key
+   ```
+
+2. Alternatively, you can specify a server URL directly:
+   ```
+   REMOTE_CUDA_MVS_ENABLED=True
+   REMOTE_CUDA_MVS_USE_LAN_DISCOVERY=False
+   REMOTE_CUDA_MVS_SERVER_URL=http://server-ip:8765
+   REMOTE_CUDA_MVS_API_KEY=your-shared-secret-key
+   ```
+
+### Remote Processing Features
+
+- **Automatic Server Discovery**: Find CUDA MVS servers on your local network
+- **Job Management**: Upload images, track job status, and download results
+- **Fault Tolerance**: Automatic retries, circuit breaker pattern, and error tracking
+- **Authentication**: Secure API key authentication for all remote operations
+- **Health Monitoring**: Continuous server health checks and status reporting
+
+## Usage
+
+1. Start the server:
+   ```
+   python src/main.py
+   ```
+
+2. The server will start on http://localhost:8000
+
+3. Use the MCP tools to interact with the server:
+
+   - **generate_image_gemini**: Generate an image using Google Gemini API
+     ```json
+     {
+       "prompt": "A low-poly rabbit with black background",
+       "model": "gemini-2.0-flash-exp-image-generation"
+     }
+     ```
+
+   - **generate_multi_view_images**: Generate multiple views of the same 3D object
+     ```json
+     {
+       "prompt": "A low-poly rabbit",
+       "num_views": 4
+     }
+     ```
+
+   - **create_3d_model_from_images**: Create a 3D model from approved multi-view images
+     ```json
+     {
+       "image_ids": ["view_1", "view_2", "view_3", "view_4"],
+       "output_name": "rabbit_model"
+     }
+     ```
+
+   - **create_3d_model_from_text**: Complete pipeline from text to 3D model
+     ```json
+     {
+       "prompt": "A low-poly rabbit",
+       "num_views": 4
+     }
+     ```
+
+   - **export_model**: Export a model to a specific format
+     ```json
+     {
+       "model_id": "your-model-id",
+       "format": "obj"  // or "stl", "ply", "scad", etc.
+     }
+     ```
+
+   - **discover_remote_cuda_mvs_servers**: Find CUDA MVS servers on your network
+     ```json
+     {
+       "timeout": 5
+     }
+     ```
+
+   - **get_remote_job_status**: Check the status of a remote processing job
+     ```json
+     {
+       "server_id": "server-id",
+       "job_id": "job-id"
+     }
+     ```
+
+   - **download_remote_model_result**: Download a completed model from a remote server
+     ```json
+     {
+       "server_id": "server-id",
+       "job_id": "job-id",
+       "output_name": "model-name"
+     }
+     ```
+
+   - **discover_printers**: Discover 3D printers on the network
+     ```json
+     {}
+     ```
+
+   - **print_model**: Print a model on a connected printer
+     ```json
+     {
+       "model_id": "your-model-id",
+       "printer_id": "your-printer-id"
+     }
+     ```
+
+## Image Generation Options
+
+The server supports multiple image generation options:
+
+1. **Google Gemini API** (Default): Uses the Gemini 2.0 Flash Experimental model for high-quality image generation
+   - Supports multi-view generation with consistent style
+   - Requires a Google Gemini API key
+
+2. **Venice.ai API** (Optional): Alternative image generation service
+   - Supports various models including flux-dev and fluently-xl
+   - Requires a Venice.ai API key
+
+3. **User-Provided Images**: Skip image generation and use your own images
+   - Upload images directly to the server
+   - Useful for working with existing photographs or renders
+
+## Multi-View Workflow
+
+The server implements a multi-view workflow for 3D reconstruction:
+
+1. **Image Generation**: Generate multiple views of the same 3D object
+2. **Image Approval**: Review and approve/deny each generated image
+3. **3D Reconstruction**: Convert approved images into a 3D model using CUDA MVS
+   - Can be processed locally or on a remote server within your LAN
+4. **Model Refinement**: Optionally refine the model using OpenSCAD
+
+## Remote Processing Workflow
+
+The remote processing workflow allows you to offload computationally intensive tasks to more powerful machines:
+
+1. **Server Discovery**: Automatically discover CUDA MVS servers on your network
+2. **Image Upload**: Upload approved multi-view images to the remote server
+3. **Job Processing**: Process the images on the remote server using CUDA MVS
+4. **Status Tracking**: Monitor the job status and progress
+5. **Result Download**: Download the completed 3D model when processing is finished
+
+## Supported Export Formats
+
+The server supports exporting models in various formats:
+
+- **OBJ**: Wavefront OBJ format (standard 3D model format)
+- **STL**: Standard Triangle Language (for 3D printing)
+- **PLY**: Polygon File Format (for point clouds and meshes)
+- **SCAD**: OpenSCAD source code (for parametric models)
+- **CSG**: OpenSCAD CSG format (preserves all parametric properties)
+- **AMF**: Additive Manufacturing File Format (preserves some metadata)
+- **3MF**: 3D Manufacturing Format (modern replacement for STL with metadata)
+
+## Web Interface
+
+The server provides a web interface for:
+
+- Generating and approving multi-view images
+- Previewing 3D models from different angles
+- Downloading models in various formats
+
+Access the interface at http://localhost:8000/ui/
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/mcp_servers/openscad-mcp-server/legacy/implementation_plan.md

@@ -0,0 +1,100 @@
+# Implementation Plan: OpenSCAD-MCP-Server with AI-Driven 3D Modeling
+
+## 1. Project Structure Updates
+
+### 1.1 New Modules
+```
+src/
+├── ai/
+│   ├── venice_api.py         # Venice.ai API client
+│   └── sam_segmentation.py   # SAM2 integration
+├── models/
+│   └── threestudio_generator.py  # threestudio integration
+└── workflow/
+    └── image_to_model_pipeline.py  # Workflow orchestration
+```
+
+### 1.2 Dependencies
+Add to requirements.txt:
+```
+# Image Generation - Venice.ai API
+# (using existing requests and python-dotenv)
+
+# Object Segmentation - SAM2
+torch>=2.0.0
+torchvision>=0.15.0
+opencv-python>=4.7.0
+segment-anything>=1.0
+
+# 3D Model Creation - threestudio
+ninja>=1.11.0
+pytorch3d>=0.7.4
+trimesh>=3.21.0
+```
+
+## 2. Component Implementation
+
+### 2.1 Venice.ai API Integration
+- Create `VeniceImageGenerator` class in `venice_api.py`
+- Implement authentication with API key
+- Add image generation with Flux model
+- Support image downloading and storage
+
+### 2.2 SAM2 Integration
+- Create `SAMSegmenter` class in `sam_segmentation.py`
+- Implement model loading with PyTorch
+- Add object segmentation from images
+- Support mask generation and visualization
+
+### 2.3 threestudio Integration
+- Create `ThreeStudioGenerator` class in `threestudio_generator.py`
+- Implement 3D model generation from masked images
+- Support model export in formats compatible with OpenSCAD
+- Add preview image generation
+
+### 2.4 OpenSCAD Integration
+- Extend `OpenSCADWrapper` with methods to:
+  - Import 3D models from threestudio
+  - Generate parametric modifications
+  - Create multi-angle previews
+  - Export in various formats
+
+### 2.5 Workflow Orchestration
+- Create `ImageToModelPipeline` class to coordinate the workflow:
+  1. Generate image with Venice.ai API
+  2. Segment object with SAM2
+  3. Create 3D model with threestudio
+  4. Import into OpenSCAD for parametric editing
+
+## 3. MCP Tool Integration
+
+Add new MCP tools to main.py:
+- `generate_image_from_text`: Generate images using Venice.ai
+- `segment_object_from_image`: Segment objects using SAM2
+- `generate_3d_model_from_image`: Create 3D models using threestudio
+- `generate_model_from_text`: End-to-end pipeline from text to 3D model
+
+## 4. Hardware Requirements
+
+- SAM2: NVIDIA GPU with 6GB+ VRAM
+- threestudio: NVIDIA GPU with 6GB+ VRAM
+- Consider implementing fallback options for environments with limited GPU resources
+
+## 5. Implementation Phases
+
+### Phase 1: Basic Integration
+- Implement Venice.ai API client
+- Set up SAM2 with basic segmentation
+- Create threestudio wrapper with minimal functionality
+- Extend OpenSCAD wrapper for model import
+
+### Phase 2: Workflow Orchestration
+- Implement the full pipeline
+- Add MCP tools for each component
+- Create end-to-end workflow tool
+
+### Phase 3: Optimization and Refinement
+- Optimize for performance
+- Add error handling and recovery
+- Implement corrective cycle for mesh modification
+- Add user interface improvements

package/mcp_servers/openscad-mcp-server/legacy/old/download_sam2_checkpoint.py

@@ -0,0 +1,115 @@
+import os
+import sys
+import logging
+import requests
+import argparse
+from pathlib import Path
+from tqdm import tqdm
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# SAM2 checkpoint URLs
+CHECKPOINT_URLS = {
+    "vit_h": "https://dl.fbaipublicfiles.com/segment_anything_2/sam2_vit_h.pth",
+    "vit_l": "https://dl.fbaipublicfiles.com/segment_anything_2/sam2_vit_l.pth",
+    "vit_b": "https://dl.fbaipublicfiles.com/segment_anything_2/sam2_vit_b.pth"
+}
+
+# Checkpoint sizes (approximate, in MB)
+CHECKPOINT_SIZES = {
+    "vit_h": 2560,  # 2.5 GB
+    "vit_l": 1250,  # 1.2 GB
+    "vit_b": 380    # 380 MB
+}
+
+def download_checkpoint(model_type="vit_b", output_dir="models"):
+    """
+    Download SAM2 checkpoint.
+    
+    Args:
+        model_type: Model type to download (vit_h, vit_l, vit_b)
+        output_dir: Directory to save the checkpoint
+    
+    Returns:
+        Path to the downloaded checkpoint
+    """
+    if model_type not in CHECKPOINT_URLS:
+        raise ValueError(f"Invalid model type: {model_type}. Available types: {list(CHECKPOINT_URLS.keys())}")
+    
+    url = CHECKPOINT_URLS[model_type]
+    output_path = os.path.join(output_dir, f"sam2_{model_type}.pth")
+    
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Check if checkpoint already exists
+    if os.path.exists(output_path):
+        logger.info(f"Checkpoint already exists at {output_path}")
+        return output_path
+    
+    # Download checkpoint
+    logger.info(f"Downloading SAM2 checkpoint ({model_type}) from {url}")
+    logger.info(f"Approximate size: {CHECKPOINT_SIZES[model_type]} MB")
+    
+    try:
+        # Stream download with progress bar
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        
+        # Get total file size
+        total_size = int(response.headers.get('content-length', 0))
+        
+        # Create progress bar
+        with open(output_path, 'wb') as f, tqdm(
+            desc=f"Downloading {model_type}",
+            total=total_size,
+            unit='B',
+            unit_scale=True,
+            unit_divisor=1024,
+        ) as pbar:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+                    pbar.update(len(chunk))
+        
+        logger.info(f"Checkpoint downloaded to {output_path}")
+        return output_path
+    
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error downloading checkpoint: {str(e)}")
+        # Remove partial download if it exists
+        if os.path.exists(output_path):
+            os.remove(output_path)
+        raise
+    except KeyboardInterrupt:
+        logger.info("Download interrupted by user")
+        # Remove partial download if it exists
+        if os.path.exists(output_path):
+            os.remove(output_path)
+        sys.exit(1)
+
+def main():
+    """Main function to parse arguments and download checkpoint."""
+    parser = argparse.ArgumentParser(description="Download SAM2 checkpoint")
+    parser.add_argument("--model_type", type=str, default="vit_b", choices=list(CHECKPOINT_URLS.keys()),
+                        help="Model type to download (vit_h, vit_l, vit_b). Default: vit_b (smallest)")
+    parser.add_argument("--output_dir", type=str, default="models",
+                        help="Directory to save the checkpoint")
+    
+    args = parser.parse_args()
+    
+    # Print model information
+    logger.info(f"Selected model: {args.model_type}")
+    logger.info(f"Approximate sizes: vit_h: 2.5 GB, vit_l: 1.2 GB, vit_b: 380 MB")
+    
+    try:
+        checkpoint_path = download_checkpoint(args.model_type, args.output_dir)
+        logger.info(f"Checkpoint ready at: {checkpoint_path}")
+    except Exception as e:
+        logger.error(f"Failed to download checkpoint: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()