@synsci/cli-darwin-x64 1.1.97 → 1.1.99

package/bin/skills/modal-research-gpu/SKILL.md

@@ -1,238 +0,0 @@
----
-name: modal-research-gpu
-description: GPU-accelerated scientific research on Modal — simulations, numerical methods, Monte Carlo, molecular dynamics, large-scale data processing. NOT for ML training or inference (use gpu-training or modal skills instead).
-version: 1.0.0
-author: Synthetic Sciences
-license: MIT
-tags: [GPU, Scientific Computing, Simulations, Modal, Research, HPC, Numerical Methods]
-dependencies: [modal>=0.73.0]
----
-
-# Modal Research GPU
-
-Run GPU-accelerated scientific research workloads on Modal. This skill covers simulations, numerical computation, Monte Carlo methods, molecular dynamics, large-scale data processing, and batch scientific computing.
-
-**NOT for ML training/inference** — use `gpu-training` (Tinker/Modal training) or `modal` (inference serving) instead.
-
-## When to Use This Skill
-
-| Workload | Example |
-|----------|---------|
-| Monte Carlo simulations | Drug binding free energy, financial risk modeling, particle physics |
-| Molecular dynamics | GROMACS, OpenMM, LAMMPS on GPU |
-| Numerical PDE solvers | Fluid dynamics (CFD), heat transfer, electromagnetics |
-| Large-scale data processing | Genomics pipelines, image processing, signal analysis |
-| GPU-accelerated linear algebra | CuPy/RAPIDS matrix operations, eigenvalue problems |
-| Parallel parameter sweeps | Sensitivity analysis, hyperspace exploration |
-| Scientific visualization | Volume rendering, 3D reconstruction |
-
-## Credential Setup
-
-```bash
-# Verify Modal credentials (auto-injected by synsc)
-[ -n "$MODAL_TOKEN_ID" ] && echo "MODAL_TOKEN_ID set" || echo "NOT SET"
-[ -n "$MODAL_TOKEN_SECRET" ] && echo "MODAL_TOKEN_SECRET set" || echo "NOT SET"
-```
-
-If not set: connect Modal at https://cli.syntheticsciences.ai -> Services, then restart synsc.
-
-## GPU Selection Guide
-
-| GPU | VRAM | Best For | Cost/hr (approx) |
-|-----|------|----------|-------------------|
-| T4 | 16 GB | Light numerical work, small simulations | $0.59 |
-| L4 | 24 GB | Medium simulations, data processing | $0.80 |
-| A10G | 24 GB | General scientific computing | $1.10 |
-| A100 40GB | 40 GB | Large simulations, molecular dynamics | $3.40 |
-| A100 80GB | 80 GB | Very large state spaces, multi-physics | $4.58 |
-| H100 | 80 GB | Maximum throughput, large-scale Monte Carlo | $6.98 |
-
-**Rule of thumb:** Start with A10G. Move to A100 only if VRAM or throughput is insufficient.
-
-## Scientific Python Stack
-
-```python
-image = (
-    modal.Image.debian_slim(python_version="3.12")
-    .pip_install(
-        # Core scientific
-        "numpy>=2.0", "scipy>=1.14", "pandas>=2.2",
-        # GPU-accelerated
-        "cupy-cuda12x>=13.0",  # GPU arrays (drop-in NumPy replacement)
-        "jax[cuda12]>=0.4.30",  # Differentiable computing
-        # Domain-specific (add as needed)
-        # "openmm>=8.1",       # Molecular dynamics
-        # "pycuda>=2024.1",    # Raw CUDA kernels
-        # "rapids-cudf>=24.0", # GPU DataFrames
-    )
-)
-```
-
-## Pattern: Basic GPU Computation
-
-```python
-import modal
-
-app = modal.App("research-compute")
-
-image = (
-    modal.Image.debian_slim(python_version="3.12")
-    .pip_install("numpy", "scipy", "cupy-cuda12x")
-)
-
-@app.function(image=image, gpu="A10G", timeout=3600)
-def gpu_compute(params: dict):
-    import cupy as cp
-    import numpy as np
-
-    # CuPy — NumPy API on GPU
-    matrix = cp.random.randn(params["size"], params["size"], dtype=cp.float64)
-    eigenvalues = cp.linalg.eigvalsh(matrix @ matrix.T)
-    return cp.asnumpy(eigenvalues)
-```
-
-## Pattern: Monte Carlo Simulation (Parallel)
-
-```python
-@app.function(image=image, gpu="A10G", timeout=7200)
-def monte_carlo_batch(seed: int, n_samples: int, params: dict):
-    import cupy as cp
-
-    rng = cp.random.default_rng(seed)
-    # Run simulation on GPU
-    samples = rng.standard_normal((n_samples, params["dim"]))
-    results = run_simulation_kernel(samples, params)
-    return cp.asnumpy(results)
-
-@app.local_entrypoint()
-def main():
-    # Fan out to 100 GPUs in parallel
-    seeds = list(range(100))
-    results = list(monte_carlo_batch.map(
-        seeds,
-        kwargs={"n_samples": 1_000_000, "params": {"dim": 3}},
-    ))
-    aggregate(results)
-```
-
-## Pattern: Molecular Dynamics
-
-```python
-image_md = (
-    modal.Image.from_registry("nvcr.io/hpc/openmm:8.1.1")
-    .pip_install("mdtraj", "parmed")
-)
-
-@app.function(image=image_md, gpu="A100", timeout=14400)
-def run_md_simulation(pdb_path: str, steps: int = 1_000_000):
-    import openmm
-    import openmm.app as app
-
-    pdb = app.PDBFile(pdb_path)
-    forcefield = app.ForceField("amber14-all.xml", "amber14/tip3pfb.xml")
-    system = forcefield.createSystem(
-        pdb.topology,
-        nonbondedMethod=app.PME,
-        nonbondedCutoff=1.0,
-        constraints=app.HBonds,
-    )
-    integrator = openmm.LangevinMiddleIntegrator(300, 1.0, 0.004)
-    platform = openmm.Platform.getPlatformByName("CUDA")
-    simulation = app.Simulation(pdb.topology, system, integrator, platform)
-    simulation.context.setPositions(pdb.positions)
-    simulation.minimizeEnergy()
-    simulation.step(steps)
-```
-
-## Pattern: Parameter Sweep with Volume Storage
-
-```python
-vol = modal.Volume.from_name("research-results", create_if_missing=True)
-
-@app.function(image=image, gpu="T4", volumes={"/results": vol}, timeout=3600)
-def sweep_point(param_set: dict):
-    import numpy as np
-    result = run_experiment(param_set)
-    path = f"/results/sweep_{param_set['id']}.npz"
-    np.savez(path, **result)
-    vol.commit()
-    return {"id": param_set["id"], "metric": result["metric"]}
-
-@app.local_entrypoint()
-def sweep():
-    param_grid = [{"id": i, "alpha": a, "beta": b}
-                  for i, (a, b) in enumerate(grid)]
-    results = list(sweep_point.map(param_grid))
-```
-
-## Pattern: JAX on GPU (Differentiable Scientific Computing)
-
-```python
-image_jax = (
-    modal.Image.debian_slim(python_version="3.12")
-    .pip_install("jax[cuda12]", "jaxlib", "diffrax", "equinox")
-)
-
-@app.function(image=image_jax, gpu="A100", timeout=7200)
-def solve_pde(params: dict):
-    import jax
-    import jax.numpy as jnp
-    import diffrax
-
-    # Solve ODE/PDE system with automatic differentiation
-    def vector_field(t, y, args):
-        return -args["k"] * y + jnp.sin(t)
-
-    sol = diffrax.diffeqsolve(
-        diffrax.ODETerm(vector_field),
-        diffrax.Tsit5(),
-        t0=0, t1=params["t_final"], dt0=0.01,
-        y0=jnp.array(params["y0"]),
-        args=params,
-    )
-    return {"t": sol.ts.tolist(), "y": sol.ys.tolist()}
-```
-
-## Cost Management
-
-1. **Estimate before running**: Calculate GPU-hours = (estimated_time × n_parallel_jobs) / 3600 × hourly_rate
-2. **Start small**: Test with T4/L4 and small problem sizes before scaling to A100/H100
-3. **Use timeouts**: Always set `timeout` to prevent runaway costs
-4. **Spot-check results**: Run a small batch first, verify correctness, then scale
-5. **Volume cleanup**: Delete old volumes when done: `modal volume rm <name>`
-
-## CRITICAL: Cost Approval
-
-Before launching ANY GPU job:
-1. Present estimated cost, GPU type, duration, and number of parallel jobs
-2. Wait for explicit user approval
-3. If declined, suggest smaller scale or cheaper GPU tier
-
-## Multi-GPU (Single Node)
-
-```python
-@app.function(image=image, gpu="A100:4", timeout=14400)
-def multi_gpu_compute():
-    import jax
-    devices = jax.devices()  # 4 GPUs available
-    # Use jax.pmap or sharded arrays for multi-GPU
-```
-
-## Retrieving Results
-
-```python
-# Mount a Volume for persistent storage
-vol = modal.Volume.from_name("my-research", create_if_missing=True)
-
-@app.function(volumes={"/data": vol}, gpu="A10G")
-def compute_and_save():
-    # ... compute ...
-    np.save("/data/results.npy", results)
-    vol.commit()
-
-# Later, download from another function or locally
-@app.local_entrypoint()
-def download():
-    vol = modal.Volume.from_name("my-research")
-    # Use modal volume get my-research /results.npy ./local_results.npy
-```

package/bin/skills/model-economics/SKILL.md

@@ -1,238 +0,0 @@
----
-name: model-economics
-description: Cost modeling and ROI analysis for specialized LLM development. Use when deciding whether to train a custom model, estimating total cost, or calculating break-even vs frontier APIs. Covers training costs, inference costs, and time-to-ROI projections.
-version: 1.0.0
-author: Synthetic Sciences
-license: MIT
-tags: [Economics, Cost Analysis, ROI, Break-Even, Training Cost, Inference Cost, Model Flywheel, Business Case]
-dependencies: []
----
-
-# Model Economics: Cost Analysis for LLM Specialization
-
-## When to Use This Skill
-
-Use this skill as the **first step** of any flywheel assessment to determine:
-- Is it worth training a specialized model?
-- What will the total investment be?
-- When will the specialized model break even vs frontier APIs?
-- What's the ongoing cost comparison?
-
-## Frontier API Cost Model
-
-**Important**: Use `websearch` to get current pricing — these change frequently. Reference tiers as of early 2026:
-
-### Premium Tier ($5-25/M output tokens)
-| Model | Input ($/M) | Output ($/M) | Notes |
-|-------|-------------|--------------|-------|
-| Claude Opus 4.6 | $5.00 | $25.00 | Highest capability |
-| GPT-5.2 Pro | $21.00 | $168.00 | Reasoning-heavy |
-
-**Savings potential**: Highest. A specialized 8B model costs ~$0.05-0.15/M tokens to serve = 100-500x cheaper.
-
-### Standard Tier ($1.75-14/M output tokens)
-| Model | Input ($/M) | Output ($/M) | Notes |
-|-------|-------------|--------------|-------|
-| GPT-5.2 Chat | $1.75 | $14.00 | Most popular |
-| Claude Sonnet 4.5 | $3.00 | $15.00 | Good balance |
-| Qwen3 Max | $1.20 | $6.00 | Cost-effective |
-
-**Savings potential**: Strong at volume. Break-even is achievable with moderate traffic.
-
-### Budget Tier ($0.10-3/M output tokens)
-| Model | Input ($/M) | Output ($/M) | Notes |
-|-------|-------------|--------------|-------|
-| Gemini 3 Flash | $0.50 | $3.00 | Fast, cheap |
-| GLM 4.7 | $0.40 | $1.50 | Very cost-effective |
-| Mistral Small | $0.10 | $0.30 | Cheapest commercial |
-
-**Savings potential**: Harder to beat on cost alone. Specialize for quality, not cost.
-
-### Free / Near-Free
-Many open-weight models available on OpenRouter at $0. If you only need basic capability, self-hosting these is essentially free beyond GPU cost.
-
-## Training Cost Estimation
-
-### Tinker (Managed LoRA)
-Cheapest option for supported models. No GPU management.
-
-| Model Size | Method | Cost/1K examples | Duration |
-|------------|--------|-------------------|----------|
-| 8B | LoRA | ~$2-5 | 15-30 min |
-| 14B | LoRA | ~$5-10 | 30-60 min |
-| 32B | LoRA | ~$10-25 | 1-3 hours |
-| 70B | LoRA | ~$25-60 | 3-8 hours |
-
-Load `tinker-training-cost` skill for exact per-token rates.
-
-### Modal (Serverless GPU)
-
-| GPU | Cost/Hour | Best For |
-|-----|-----------|----------|
-| A100-40GB | ~$1.10 | 7-14B LoRA, 7B full |
-| A100-80GB | ~$1.60 | 14-32B LoRA, 14B full |
-| H100-80GB | ~$3.25 | 32-70B LoRA, large batches |
-
-**Typical training runs**:
-- 8B LoRA, 5K examples, 3 epochs: ~1-2 hours on A100 = $1-3
-- 14B LoRA, 10K examples, 3 epochs: ~3-5 hours on A100-80GB = $5-8
-- 70B LoRA, 10K examples, 2 epochs: ~8-12 hours on H100 = $26-39
-
-### TensorPool (Dedicated GPU)
-
-| GPU | Cost/Hour | Best For |
-|-----|-----------|----------|
-| A100-80GB | ~$1.50 | Standard training |
-| H200-141GB | ~$3.00 | Large models, fast training |
-| B200-192GB | ~$4.50 | Cutting-edge, maximum throughput |
-
-Best for: Multi-day training, large-scale RL, dedicated inference.
-
-## Inference Cost Comparison
-
-The key calculation: what does it cost to serve the specialized model vs the frontier API?
-
-### Self-Hosted Inference Cost
-
-```python
-def inference_cost_per_million_tokens(gpu_cost_per_hour, tokens_per_second):
-    """Calculate cost per million tokens for self-hosted inference.
-
-    Args:
-        gpu_cost_per_hour: GPU rental cost (e.g., $3.25 for H100)
-        tokens_per_second: Model throughput (varies by model size and batch)
-    """
-    tokens_per_hour = tokens_per_second * 3600
-    cost_per_token = gpu_cost_per_hour / tokens_per_hour
-    cost_per_million = cost_per_token * 1_000_000
-    return cost_per_million
-```
-
-### Reference Throughput (vLLM, single GPU)
-
-| Model Size | GPU | Tokens/sec (batch) | Cost/M tokens |
-|------------|-----|-------------------|---------------|
-| 8B | A100-80GB | ~3,000-5,000 | $0.09-0.15 |
-| 8B | H100-80GB | ~5,000-8,000 | $0.11-0.18 |
-| 14B | A100-80GB | ~1,500-3,000 | $0.15-0.30 |
-| 14B | H100-80GB | ~3,000-5,000 | $0.18-0.30 |
-| 32B | H100-80GB | ~800-1,500 | $0.60-1.10 |
-| 70B | 2xH100 | ~500-1,000 | $1.80-3.60 |
-
-**Key insight**: A specialized 8B model on Modal/TensorPool costs **$0.05-0.15/M tokens** vs **$5-25/M** for premium frontier = **50-500x cheaper per request**.
-
-## Break-Even Calculator
-
-```python
-def break_even_analysis(
-    monthly_api_spend: float,
-    training_cost: float,
-    monthly_inference_cost: float,
-    setup_hours: float = 40,
-    hourly_rate: float = 100,
-):
-    """Calculate break-even timeline for model specialization.
-
-    Args:
-        monthly_api_spend: Current monthly frontier API cost
-        training_cost: One-time training cost (GPU + data prep)
-        monthly_inference_cost: Monthly cost to serve specialized model
-        setup_hours: Engineering time to set up pipeline
-        hourly_rate: Engineering cost per hour
-    """
-    engineering_cost = setup_hours * hourly_rate
-    total_upfront = training_cost + engineering_cost
-    monthly_savings = monthly_api_spend - monthly_inference_cost
-
-    if monthly_savings <= 0:
-        return {
-            "viable": False,
-            "reason": "Specialized model costs more to serve than frontier API",
-            "monthly_savings": monthly_savings,
-        }
-
-    months_to_break_even = total_upfront / monthly_savings
-
-    return {
-        "viable": True,
-        "total_upfront_cost": total_upfront,
-        "training_cost": training_cost,
-        "engineering_cost": engineering_cost,
-        "monthly_api_spend": monthly_api_spend,
-        "monthly_inference_cost": monthly_inference_cost,
-        "monthly_savings": monthly_savings,
-        "months_to_break_even": round(months_to_break_even, 1),
-        "annual_savings": monthly_savings * 12 - total_upfront,
-        "year_2_savings": monthly_savings * 12,  # Fully amortized
-    }
-
-
-# Example: Replace GPT-4o for a specific task
-result = break_even_analysis(
-    monthly_api_spend=5000,       # $5K/month on GPT-4o
-    training_cost=500,            # $500 for LoRA fine-tune + data prep
-    monthly_inference_cost=200,   # $200/month on Modal (8B model)
-    setup_hours=40,               # 1 week of engineering
-    hourly_rate=100,              # $100/hr engineer
-)
-# Result: Break-even in ~1.1 months, $52K annual savings after year 1
-```
-
-## ROI Timeline Template
-
-| Month | Frontier Cost | Specialized Cost | Cumulative Savings | Notes |
-|-------|--------------|-----------------|-------------------|-------|
-| 0 | — | $4,500 upfront | -$4,500 | Training + engineering |
-| 1 | $5,000 | $200 | $300 | First month live |
-| 2 | $5,000 | $200 | $5,100 | Break-even |
-| 3 | $5,000 | $200 | $9,900 | |
-| 6 | $5,000 | $200 | $24,300 | |
-| 12 | $5,000 | $300 | $52,200 | Includes retrain cost |
-
-## Decision Framework
-
-### Strong Case for Specialization
-- Monthly API spend > $1,000
-- Constrained task (classification, extraction, formatting, domain Q&A)
-- Production data available (logs, corrections, accept/reject signals)
-- Quality requirements are well-defined and measurable
-- Task doesn't change frequently
-
-### Weak Case for Specialization
-- Monthly API spend < $500
-- Diverse, open-ended tasks (general assistant)
-- No production data to train on
-- Rapid model improvement expected (new frontier models releasing soon)
-- Task requires reasoning at the frontier level
-- Small team with no ML engineering capacity
-
-### Hybrid Approach
-Route easy requests to specialized model, hard ones to frontier:
-- **90% of requests** → Specialized 8B (cheap, fast)
-- **10% of requests** → Frontier fallback (complex, novel)
-- **Result**: 80-90% cost reduction while maintaining quality on hard cases
-
-## Quick Assessment Questions
-
-Ask the user these to determine viability:
-
-1. **What's your monthly frontier API spend?**
-   - < $500: Probably not worth it (low ROI)
-   - $500-2K: Worth investigating
-   - $2K+: Strong candidate
-   - $10K+: Almost certainly worth it
-
-2. **How constrained is the task?**
-   - Single task (classification, extraction): Great fit
-   - Few related tasks: Good fit
-   - Many diverse tasks: Harder to specialize
-
-3. **What production data do you have?**
-   - API logs with user feedback: Excellent
-   - API logs without feedback: Good (can distill)
-   - No production data: Need synthetic bootstrap
-
-4. **What's your quality bar?**
-   - Must match frontier exactly: Harder, may need bigger model
-   - 90% of frontier quality is fine: 8B LoRA likely sufficient
-   - Task-specific metrics (accuracy, format): Easiest to optimize