# Auto-optimize any model for workload type
terradev sglang optimize deepseek-ai/DeepSeek-V3

# Detect workload from description
terradev sglang detect meta-llama/Llama-2-7b-hf --user-description "Real-time API"

# Multi-replica cache-aware routing
terradev sglang router meta-llama/Llama-2-7b-hf --dp-size 8

# Automatic CUDA Graph optimization - no configuration needed
terradev provision -g H100 -n 4

# NUMA-aware endpoint selection happens automatically
# CUDA Graph compatibility is detected passively
# Warm pool prioritizes graph-compatible models

pip install terradev-cli

pip install terradev-cli[all]

terradev --help

terradev setup runpod --quick

terradev configure --provider runpod

terradev configure --provider vastai
terradev configure --provider lambda_labs
terradev configure --provider aws

terradev quote -g A100

terradev quote -g H100
terradev quote -g L40S
terradev quote -g RTX4090

terradev provision -g H100 -n 4 --parallel 6

terradev provision -g A100 -n 2 --dry-run

terradev provision -g A100 --max-price 2.50

terradev execute -i <instance-id> -c "nvidia-smi"
terradev execute -i <instance-id> -c "python train.py"

terradev run --gpu A100 --image pytorch/pytorch:latest -c "python train.py"

terradev run --gpu H100 --image vllm/vllm-openai:latest --keep-alive --port 8000

# See all running instances and current cost
terradev status --live

# Stop (keeps allocation)
terradev manage -i <instance-id> -a stop

# Restart
terradev manage -i <instance-id> -a start

# Terminate and release
terradev manage -i <instance-id> -a terminate

# View spend over the last 30 days
terradev analytics --days 30

# Find cheaper alternatives for running instances
terradev optimize

# Validate GPUs, NCCL, RDMA, and drivers before launching
terradev preflight

# Launch training on the nodes you just provisioned
terradev train --script train.py --from-provision latest

# Watch GPU utilization and cost in real time
terradev monitor --job my-job

# Check status
terradev train-status

# 6. List checkpoints when done
terradev checkpoint list --job my-job

terradev vllm auto-optimize -s workload.json -m meta-llama/Llama-2-7b-hf -g 4

terradev vllm analyze -e http://localhost:8000

terradev vllm benchmark -e http://localhost:8000 -c 10

terradev provision --task clusters/moe-template/task.yaml \
  --set model_id=Qwen/Qwen3.5-397B-A17B

terradev provision --task clusters/moe-template/task.yaml \
  --set model_id=Qwen/Qwen3.5-122B-A10B --set tp_size=4 --set gpu_count=4

terradev ml ray --deploy-pd \
  --model zai-org/GLM-5-FP8 \
  --prefill-tp 8 --decode-tp 1 --decode-dp 24

terradev k8s create my-cluster --gpu H100 --count 8 --prefer-spot

# List clusters
terradev k8s list

# Get cluster info
terradev k8s info my-cluster

# Tear down
terradev k8s destroy my-cluster

#!/bin/bash

# Complete LLM deployment workflow

# 1. Find cheapest GPU
terradev quote -g A100 --quick
# 2. Provision with auto-optimization
terradev provision -g A100 -n 2 --parallel 4
# 3. Deploy optimized vLLM
terradev ml vllm --start --instance-ip $(terradev status --json | jq -r '.[0].ip') --model meta-llama/Llama-2-7b-hf --tp-size 2
# 4. Set up monitoring
terradev monitor --endpoint llama-api --live
# 5. Add customer adapter
terradev lora add -e http://$(terradev status --json | jq -r '.[0].ip'):8000 -n customer-a -p ./adapters/customer-a

#!/bin/bash

# GLM-5 production deployment

# 1. Deploy MoE cluster
terradev provision --task clusters/moe-template/task.yaml --set model_id=zai-org/GLM-5-FP8 --set tp_size=8
# 2. Deploy monitoring
terradev k8s monitoring-stack --cluster glm-5-cluster
# 3. Set up warm pool for bursty traffic
terradev ml warm-pool --configure --strategy traffic_based --max-warm-models 5 --endpoint glm-5-api
# 4. Test failover
terradev inferx failover --endpoint glm-5-api --test-load 5000

#!/bin/bash

# Production deployment with cold start failover and multi-tenant LoRA adapters

echo "🚀 Deploying InferX + LoRA Hybrid Inference Service"

# 1. Deploy baseline reserved GPUs for steady traffic
echo "📍 Step 1: Provision reserved baseline capacity"
terradev provision -g H100 -n 2 --parallel 4 \
  --tag baseline-llm \
  --max-price 2.50

BASELINE_IP=$(terradev status --json | jq -r '.[] | select(.tags[] | contains("baseline-llm")) | .ip' | head -1)

# 2. Deploy optimized vLLM with LoRA support on baseline
echo "📍 Step 2: Deploy vLLM with LoRA adapter support"
terradev ml vllm --start \
  --instance-ip $BASELINE_IP \
  --model meta-llama/Llama-2-7b-hf \
  --tp-size 2 \
  --enable-lora \
  --enable-kv-offloading \
  --enable-sleep-mode \
  --port 8000

# 3. Load customer-specific LoRA adapters
echo "📍 Step 3: Load multi-tenant LoRA adapters"
terradev lora add -e http://$BASELINE_IP:8000 \
  -n customer-enterprise-a \
  -p ./adapters/customer-enterprise-a

terradev lora add -e http://$BASELINE_IP:8000 \
  -n customer-startup-b \
  -p ./adapters/customer-startup-b

terradev lora add -e http://$BASELINE_IP:8000 \
  -n customer-internal \
  -p ./adapters/customer-internal

# 4. Configure InferX for cold start and burst handling
echo "📍 Step 4: Configure InferX for serverless burst capacity"
terradev inferx deploy \
  --endpoint burst-llm-api \
  --model-id meta-llama/Llama-2-7b-hf \
  --baseline-endpoint http://$BASELINE_IP:8000 \
  --cold-start-threshold 100 \
  --burst-capacity 10 \
  --failover-strategy active-passive

# 5. Set up intelligent routing with semantic awareness
echo "📍 Step 5: Configure semantic routing for multi-tenant requests"
cat > routing-config.yaml << EOF
rules:
  - name: "enterprise_customers"
    condition: "header:x-customer-id == 'enterprise-a'"
    route_to: "baseline"
    lora_adapter: "customer-enterprise-a"
    strategy: "latency"

  - name: "startup_customers" 
    condition: "header:x-customer-id == 'startup-b'"
    route_to: "baseline"
    lora_adapter: "customer-startup-b"
    strategy: "cost"

  - name: "internal_workloads"
    condition: "header:x-api-key starts_with 'internal_'"
    route_to: "baseline"
    lora_adapter: "customer-internal"
    strategy: "throughput"

  - name: "burst_traffic"
    condition: "request_rate > 50"
    route_to: "inferx"
    strategy: "auto-scale"

  - name: "fallback"
    condition: "default"
    route_to: "baseline"
    lora_adapter: "customer-internal"
    strategy: "round-robin"
EOF

terradev semantic-router --deploy --config routing-config.yaml

# 6. Configure warm pool for frequently used adapters
echo "📍 Step 6: Configure warm pool for LoRA adapters"
terradev ml warm-pool --configure \
  --strategy adapter_based \
  --max-warm-models 5 \
  --warm-adapters customer-enterprise-a,customer-internal \
  --idle-eviction-minutes 10 \
  --enable-predictive-warming

# 7. Set up comprehensive monitoring and alerting
echo "📍 Step 7: Deploy monitoring stack"
terradev k8s monitoring-stack --cluster production

# Configure W&B for ML observability
terradev ml wandb --setup-alerts \
  --endpoint http://$BASELINE_IP:8000 \
  --metric-thresholds "latency_p95<2000,throughput>100,gpu_utilization>80" \
  --alert-channels slack,email

# Configure InferX-specific monitoring
terradev inferx status --endpoint burst-llm-api --detailed
terradev inferx failover --endpoint burst-llm-api --test-load 1000

# 8. Test the complete setup
echo "📍 Step 8: Testing complete deployment"
echo "Testing baseline endpoint with LoRA..."
curl -X POST http://$BASELINE_IP:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "x-customer-id: enterprise-a" \
  -d '{
    "model": "meta-llama/Llama-2-7b-hf",
    "messages": [{"role": "user", "content": "Hello from enterprise customer!"}],
    "max_tokens": 100
  }'

echo "Testing InferX burst endpoint..."
curl -X POST https://inferx.terradev.cloud/burst-llm-api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $INFERX_API_KEY" \
  -d '{
    "model": "meta-llama/Llama-2-7b-hf", 
    "messages": [{"role": "user", "content": "Hello from burst traffic!"}],
    "max_tokens": 100
  }'

echo "📍 Step 9: Deployment summary"
echo "✅ Baseline endpoint: http://$BASELINE_IP:8000"
echo "✅ InferX endpoint: https://inferx.terradev.cloud/burst-llm-api"
echo "✅ LoRA adapters loaded: $(terradev lora list -e http://$BASELINE_IP:8000 --count)"
echo "✅ Semantic routing: Active"
echo "✅ Warm pool: Configured for top adapters"
echo "✅ Monitoring: W&B + Prometheus + Grafana"

# 10. Set up automated LoRA updates
echo "📍 Step 10: Configure automated LoRA adapter updates"
cat > lora-update-config.yaml << EOF
adapters:
  - name: "customer-enterprise-a"
    path: "./adapters/customer-enterprise-a"
    update_strategy: "rolling"
    health_check: true
    rollback_on_failure: true
    
  - name: "customer-startup-b"
    path: "./adapters/customer-startup-b" 
    update_strategy: "blue_green"
    health_check: true
    rollback_on_failure: true

monitoring:
  update_frequency: "hourly"
  health_check_timeout: "30s"
  rollback_threshold: "error_rate > 0.05"
EOF

terradev lora auto-update --config lora-update-config.yaml

echo "🎉 InferX + LoRA Hybrid Deployment Complete!"
echo ""
echo "📊 Next Steps:"
echo "1. Monitor performance: terradev monitor --endpoint hybrid-llm --live"
echo "2. Check LoRA performance: terradev lora metrics --endpoint http://$BASELINE_IP:8000"
echo "3. Test failover: terradev inferx failover --endpoint burst-llm-api --test-load 5000"
echo "4. Update adapters: terradev lora update -n customer-enterprise-a -p ./new-adapters/"

## Quick Reference
```bash
# Set up cloud provider credentials
terradev configure

# Real-time GPU pricing across up to 19 clouds
terradev quote -g H100 

# Provision with auto topology optimization
terradev provision -g H100 -n 4

# Provision + deploy + run in one command
terradev run --gpu A100 --image ...

# View running instances and costs
terradev status --live

# Launch training on provisioned nodes
terradev train --from-provision latest

# Auto-tune 6 critical vLLM knobs
terradev vllm auto-optimize

# Topology-optimized Kubernetes cluster
terradev k8s create

# Cost analytics
terradev analytics --days 30

# Find cheaper alternatives
terradev optimize

# Basic installation
pip install terradev-cli

# With all cloud provider SDKs
pip install terradev-cli[all]

# Individual provider support
pip install terradev-cli[aws]      # AWS
pip install terradev-cli[gcp]      # Google Cloud
pip install terradev-cli[azure]    # Azure
pip install terradev-cli[hf]       # HuggingFace Spaces

# Configure multiple providers
terradev configure --provider runpod
terradev configure --provider vastai
terradev configure --provider aws
terradev configure --provider gcp

# Stage local dataset near compute
terradev stage -d ./my-dataset --target-regions us-east-1,eu-west-1

# Cache a HuggingFace dataset near target regions
terradev stage --hf-dataset allenai/C4 --target-regions us-east-1,eu-west-1

# Cache with specific split and configuration
terradev stage --hf-dataset HuggingFaceH4/llava-instruct-mistral-7b --split train --target-regions us-west-2,eu-central-1

# Cache multiple datasets in parallel
terradev stage --hf-dataset "allenai/C4,mozilla/common-voice,bookcorpus/openwebtext" --target-regions us-east-1,eu-west-1,ap-southeast-1

# Filter, deduplicate, and compress in one pass
terradev stage --hf-dataset allenai/C4 --target-regions us-east-1 --process "filter english,remove duplicates" --format parquet --compression zstd

# Stage with size limits and sampling
terradev stage --hf-dataset mozilla/common-voice --target-regions us-east-1 --max-size 100GB --sample-rate 0.1

# Stage with full preprocessing pipeline
terradev stage --hf-dataset HuggingFaceH4/ultrachat_200k --target-regions us-east-1 --preprocess "tokenize,truncate_length=2048,remove_pii"

# Provision multiple nodes for distributed training
terradev provision -g H100 -n 4 --parallel 6

# Verify nodes are ready and interconnects are healthy
terradev status --live
terradev preflight

# Simple distributed training
terradev train --script train.py --from-provision latest

# Advanced configuration with tensor and pipeline parallelism
terradev train --script train.py --framework torchrun --from-provision latest --tp-size 2 --pp-size 2 --script-args "--epochs 10 --batch-size 32"

# Ray advanced orchestration
terradev train --script train.py --backend ray --from-provision latest --framework accelerate --script-args "--config config.yaml"

# FlashOptim applies automatically. Check if it was enabled
terradev train-status --job my-job | grep flashoptim

# Manual override
terradev train --script train.py --flashoptim on --flashoptim-optimizer adamw --from-provision latest

# Real-time metrics — GPU utilization, memory, temperature, cost
terradev monitor --job my-training-job --live

# Check all active jobs
terradev train-status

# GPU utilization across all nodes
terradev monitor --job my-job --gpu-utilization

# Checkpoint management
terradev checkpoint list --job my-job
terradev checkpoint save --job my-job

# Enable KV cache checkpointing for training jobs
terradev train --script train.py --from-provision latest --kv-checkpointing --checkpoint-interval 300

# Configure checkpoint storage backend
terradev train --script train.py --from-provision latest --kv-checkpointing --checkpoint-backend s3 --checkpoint-prefix "my-training-job"

# Training with automatic spot interruption recovery
terradev train --script train.py --from-provision latest --kv-checkpointing --auto-recovery --max-recovery-attempts 3

# Monitor checkpoint status during training
terradev checkpoint status --job my-training-job

# Manual checkpoint creation
terradev checkpoint create --job my-training-job --checkpoint-name "epoch-10-checkpoint"

# Restore from specific checkpoint
terradev train --script train.py --from-provision latest --restore-checkpoint "epoch-10-checkpoint"

# List all available checkpoints
terradev checkpoint list --job my-training-job --detailed

# Validate checkpoint integrity
terradev checkpoint validate --checkpoint "epoch-10-checkpoint"

# Configure checkpoint retention and cleanup
terradev train --script train.py --from-provision latest --kv-checkpointing --checkpoint-retention 10 --cleanup-policy "keep-latest-3"

# Enable compression for large checkpoints
terradev train --script train.py --from-provision latest --kv-checkpointing --compression-level 6 --parallel-checkpoints 2

# Configure for distributed training
terradev train --script train.py --from-provision latest --kv-checkpointing --distributed-checkpointing --rank-checkpointing

# Set up monitoring and alerts
terradev train --script train.py --from-provision latest --kv-checkpointing --checkpoint-alerts --alert-webhook "https://hooks.slack.com/..."

# Weights & Biases
terradev configure --provider wandb --api-key $WANDB_KEY
terradev ml wandb --test

# MLflow
terradev configure --provider mlflow
terradev ml mlflow --list-experiments

# LangSmith
terradev configure --provider langsmith
terradev ml langchain --create-workflow my-workflow

#!/bin/bash

# Full training pipeline: dataset to checkpoint

# 1. Stage dataset near compute before provisioning
terradev stage -d ./my-dataset --target-regions us-east-1,eu-west-1

# 2. Provision training cluster
terradev provision -g H100 -n 8 --parallel 12

# 3. Validate cluster connectivity
terradev preflight

# 4. Launch training with FlashOptim + DeepSpeed + KV Checkpointing
terradev train --script train.py --framework deepspeed --from-provision latest --tp-size 4 --pp-size 2 --kv-checkpointing --script-args "--epochs 20 --batch-size 64"

# 5. Monitor live
terradev monitor --job training-job --live

# 6. List checkpoints when done
terradev checkpoint list --job training-job

# Symptoms: Training hangs, NCCL errors, slow communication

# Diagnosis: Check inter-node connectivity
terradev preflight --detailed
terradev execute -i <node-id> -c "nccl_test -b 8G -e 8G -s 1073741824"

# Fix: Re-provision with proper NUMA alignment
terradev provision -g H100 -n 4 --parallel 6 --ensure-numa-alignment

# Symptoms: OOM errors, CUDA out of memory

# Diagnosis: Check memory usage across nodes
terradev monitor --job <job-id> --memory-usage
terradev execute -i <node-id> -c "nvidia-smi --query-gpu=memory.used,memory.total --format=csv"

# Fix: Reduce batch size or enable gradient checkpointing
terradev train --script train.py --from-provision latest --script-args "--batch-size 16 --gradient-checkpointing"

# Symptoms: Slow data loading, transfer timeouts

# Diagnosis: Check dataset cache status
terradev stage --status --dataset-id <dataset-id>
terradev stage --list-cached --region us-east-1

# Fix: Re-stage with higher parallelism or compression
terradev stage -d ./my-dataset --target-regions us-east-1 --parallel-streams 64 --compression zstd

# Symptoms: FlashOptim fails to apply, training crashes

# Diagnosis: Check FlashOptim compatibility
terradev train-status --job <job-id> | grep flashoptim
terradev preflight --flashoptim-check

# Fix: Disable FlashOptim or adjust configuration
terradev train --script train.py --flashoptim off --from-provision latest
# or with manual configuration
terradev train --script train.py --flashoptim on --flashoptim-optimizer adamw --flashoptim-master-weight-bits 8

# Symptoms: Can't resume from checkpoint, corrupted checkpoints

# Diagnosis: Verify checkpoint integrity
terradev checkpoint list --job <job-id> --verify
terradev checkpoint validate --checkpoint <checkpoint-path>

# Fix: Create new checkpoint or repair existing
terradev checkpoint save --job <job-id> --force
terradev checkpoint repair --checkpoint <checkpoint-path>

# Diagnose bottlenecks
terradev monitor --job <job-id> --bottleneck-analysis
terradev execute -i <node-id> -c "nvtop --interval 1"

# Common fixes
# 1. Enable mixed precision training
terradev train --script train.py --script-args "--mixed-precision --fp16"

# 2. Optimize data loading
terradev stage --hf-dataset <dataset> --target-regions us-east-1 --preprocess "shuffle,cache"

# 3. Increase parallelism
terradev provision -g H100 -n 8 --parallel 12

# Check network performance between nodes
terradev preflight --network-test
terradev execute -i <node-id> -c "ibstat -v"

# Fixes for RDMA/InfiniBand issues
terradev provision -g H100 -n 4 --ensure-rdma --enable-gpudirect