Jarvislabs.ai

https://docs.jarvislabs.ai/
Admin
Jarvislabs.ai is a GPU cloud platform that provides instant access to powerful GPUs and customizable...
Tokens:49,253
Snippets:709
Trust Score:8.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### Execute custom setup commands

Source: https://docs.jarvislabs.ai/cli

Examples of using the --setup flag to install system libraries, packages with specific flags, or set environment variables before script execution.

```bash
# Install a system library (containers run as root; use sudo on VMs)  
jl run . --script train.py --on 12345 --setup "apt-get update && apt-get install -y libsndfile1"  
  
# Install a package that needs special flags  
jl run . --script train.py --on 12345 --setup "pip install flash-attn --no-build-isolation"  
  
# Set environment variables  
jl run . --script train.py --on 12345 --setup "export CUDA_VISIBLE_DEVICES=0"
```

--------------------------------

### Install and Start dstack Server

Source: https://docs.jarvislabs.ai/dstack

Install the dstack package and initialize the server locally.

```bash
pip install "dstack[all]" -U  
dstack server  
```

--------------------------------

### Install and Launch JupyterLab

Source: https://docs.jarvislabs.ai/vm

Install pip and JupyterLab, then start the server with a custom token.

```bash
sudo apt install pip -y  
```

```bash
pip install jupyterlab  
```

```bash
export PATH=~/.local/bin:$PATH  
env HOME=/home/cloud jupyter lab --ip=0.0.0.0 --NotebookApp.token='<YOUR_SECRET_TOKEN>' --allow-root --port 8888 &  
```

--------------------------------

### Server Output Example

Source: https://docs.jarvislabs.ai/dstack

Example output showing the admin token and server URL after starting the dstack server.

```text
Applying ~/.dstack/server/config.yml...  
  
The admin token is "bbae0f28-d3dd-4820-bf61-8f4bb40815da"  
The server is running at http://127.0.0.1:3000/  
```

--------------------------------

### Install PyTorch via Startup Script

Source: https://docs.jarvislabs.ai/settings

Example of a shell command used within a startup script to install specific versions of PyTorch and related libraries.

```bash
pip3 install torch==1.10.1+cu113 torchvision==0.11.2+cu113 torchaudio==0.10.1+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html  
```

--------------------------------

### Install uv and Create Virtual Environment

Source: https://docs.jarvislabs.ai/host-ai-model

Setup steps for the uv package manager and creating a Python 3.12 environment.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh  
source $HOME/.local/bin/env  
```

```bash
uv venv ~/openwebui-env --python 3.12  
source ~/openwebui-env/bin/activate  
```

--------------------------------

### View Dependency Detection Logs

Source: https://docs.jarvislabs.ai/cli

Example output showing how the CLI reports the detected dependency file during the setup phase.

```text
[jl] Installing from requirements.txt    # auto-detected  
[jl] Installing from pyproject.toml      # auto-detected  
[jl] Installing from custom-reqs.txt     # --requirements override  
[jl] No dependency file detected, using template packages  # nothing found  
```

--------------------------------

### Launch Streamlit Hello World

Source: https://docs.jarvislabs.ai/deploy/streamlit

Execute the built-in Streamlit hello world example to verify the installation.

```bash
streamlit hello  
```

--------------------------------

### Run NemoClaw Onboarding

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Starts the interactive setup process with experimental flags to bypass API key requirements and detect local vLLM.

```bash
NEMOCLAW_EXPERIMENTAL=1 nemoclaw onboard
```

--------------------------------

### Install New SDK

Source: https://docs.jarvislabs.ai/api

Use these commands to install the recommended replacement SDK and CLI.

```bash
uv tool install jarvislabs  
jl setup  

```

--------------------------------

### Install CLI with pip

Source: https://docs.jarvislabs.ai/cli

Standard installation method using pip.

```bash
pip install jarvislabs
```

--------------------------------

### Install and Configure JarvisLabs CLI

Source: https://docs.jarvislabs.ai/host-ai-model

Initial setup for the JarvisLabs command-line interface and authentication.

```bash
# Install the CLI  
uv tool install jarvislabs  
  
# Authenticate and set up  
jl setup
```

--------------------------------

### Navigate to example scripts

Source: https://docs.jarvislabs.ai/comfyui

Change the directory to the folder containing ComfyUI example scripts.

```bash
cd ComfyUI/script_examples
```

--------------------------------

### Install and Login to Weights & Biases

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-flux

Set up W&B for tracking training progress.

```bash
pip install wandb  
wandb login
```

--------------------------------

### Start a run on a fresh instance

Source: https://docs.jarvislabs.ai/cli

Syntax for provisioning a new GPU instance to execute code.

```bash
jl run <target> --gpu <gpu_type> [options] [-- extra args]
```

```bash
# Run on a fresh L4
jl run train.py --gpu L4

# With requirements
jl run . --script train.py --gpu A100 --requirements requirements.txt

# Destroy instance after run (no leftover costs)
jl run train.py --gpu L4 --destroy

# Keep instance running after run (for debugging)
jl run train.py --gpu L4 --keep
```

--------------------------------

### Run a project directory with setup

Source: https://docs.jarvislabs.ai/cli

Syncs an entire directory and runs a script with custom setup commands. Subsequent runs only transfer changed files.

```bash
jl run . --script train.py --gpu A100 \
  --requirements requirements.txt \
  --setup "pip install flash-attn" \
  -- --batch-size 32 --lr 1e-4  
```

--------------------------------

### Install websocket-client

Source: https://docs.jarvislabs.ai/comfyui

Install the required websocket-client library to interact with the ComfyUI API.

```bash
pip install websocket-client
```

--------------------------------

### Install Ollama

Source: https://docs.jarvislabs.ai/tutorials/getting-started/serving-llms

Use this command to install the Ollama service on your instance.

```bash
curl -fsSL https://ollama.com/install.sh | sh  
```

--------------------------------

### Install and configure Kaggle API

Source: https://docs.jarvislabs.ai/downloaddata

Commands to install the Kaggle API and set up the required credentials file.

```bash
pip install kaggle --upgrade  
```

```bash
mkdir -p ~/.kaggle  
mv kaggle.json ~/.kaggle/  
chmod 600 ~/.kaggle/kaggle.json  
```

--------------------------------

### Authenticate the CLI interactively

Source: https://docs.jarvislabs.ai/cli

Initiates the interactive setup process to authenticate, install agent skills, and view account status.

```bash
jl setup  
```

--------------------------------

### Install Ollama and Open WebUI

Source: https://docs.jarvislabs.ai/host-ai-model

Commands to install the inference engine and the web interface.

```bash
curl -fsSL https://ollama.com/install.sh | sh  
```

```bash
uv pip install open-webui  
```

--------------------------------

### Install dependencies

Source: https://docs.jarvislabs.ai/tutorials/running-flux2-klein

Install the necessary libraries including diffusers, transformers, accelerate, and safetensors.

```bash
uv pip install git+https://github.com/huggingface/diffusers.git transformers accelerate safetensors  
```

--------------------------------

### Install Unsloth

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-llms

Install the Unsloth library in a Jupyter environment.

```bash
!pip install unsloth  

```

--------------------------------

### Install Gradio

Source: https://docs.jarvislabs.ai/deploy/gradio

Use pip to install the Gradio library in your environment.

```bash
pip install gradio  
```

--------------------------------

### Install vLLM

Source: https://docs.jarvislabs.ai/tutorials/getting-started/serving-llms

Install the vLLM package using pip.

```bash
pip install vllm  
```

--------------------------------

### Install the JarvisLabs SDK

Source: https://docs.jarvislabs.ai/sdk

Use pip or uv to install the package in your Python environment.

```bash
pip install jarvislabs
```

```bash
uv pip install jarvislabs
```

--------------------------------

### Clone and install Diffusers

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-flux

Initializes the environment by cloning the HuggingFace diffusers repository and installing it in editable mode.

```bash
git clone https://github.com/huggingface/diffusers  
cd diffusers  
pip install -e .  
```

--------------------------------

### Implicit start command

Source: https://docs.jarvislabs.ai/cli

Demonstrates that the start subcommand is optional when running a target.

```bash
# These are equivalent:
jl run train.py --gpu L4
jl run start train.py --gpu L4
```

--------------------------------

### Install Deprecated Client

Source: https://docs.jarvislabs.ai/api

Installation command for the legacy jlclient library.

```bash
pip install git+https://github.com/jarvislabsai/jlclient.git  

```

--------------------------------

### Start and Access Open WebUI

Source: https://docs.jarvislabs.ai/host-ai-model

Commands to launch the server and retrieve the public IP address.

```bash
open-webui serve  
```

```bash
jl get <machine_id>  
```

```bash
http://<your-vm-public-ip>:8080  
```

--------------------------------

### Clone and Run Gradio App

Source: https://docs.jarvislabs.ai/tutorials/running-flux2-klein

Initializes the repository and starts the Gradio interface on port 6006.

```bash
git clone https://github.com/Gladiator07/flux2-klein  
cd flux2-klein  
uv run flux2_gradio_app.py  
```

--------------------------------

### Install and Upgrade CLI with uv

Source: https://docs.jarvislabs.ai/cli

Recommended installation method using uv tool for managing the jarvislabs package.

```bash
uv tool install jarvislabs
```

```bash
uv tool upgrade jarvislabs
```

--------------------------------

### Start vLLM Server

Source: https://docs.jarvislabs.ai/tutorials/getting-started/serving-llms

Launch a vLLM server with specific model and hardware configuration flags.

```bash
vllm serve Qwen/Qwen2.5-7B-Instruct \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype bfloat16 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.9  
```

--------------------------------

### Install LLM Dependencies

Source: https://docs.jarvislabs.ai/tutorials/getting-started/platform-overview

Activate the virtual environment and install necessary libraries for running Transformers models.

```bash
source myenv/bin/activate  
uv pip install transformers accelerate hf-xet jupyter ipywidgets tqdm  
```

--------------------------------

### Install Gradio dependencies

Source: https://docs.jarvislabs.ai/tutorials/getting-started/platform-overview

Commands to activate the virtual environment and install the Gradio package.

```bash
source myenv/bin/activate  
uv pip install gradio  

```

--------------------------------

### Install Streamlit

Source: https://docs.jarvislabs.ai/deploy/streamlit

Use pip to install the Streamlit library in your environment.

```bash
pip install streamlit  
```

--------------------------------

### Start a run on an existing instance

Source: https://docs.jarvislabs.ai/cli

Syntax for executing code on a pre-existing machine using its ID.

```bash
jl run <target> --on <machine_id> [options] [-- extra args]
```

```bash
# Run a Python file
jl run train.py --on 12345

# Upload a directory and run a script inside it
jl run . --script train.py --on 12345

# Pass arguments to your script
jl run train.py --on 12345 -- --epochs 50 --lr 0.001

# Run an arbitrary remote command (no upload)
jl run --on 12345 -- python -c "print('hello from GPU')"
```

--------------------------------

### Start Ollama Server

Source: https://docs.jarvislabs.ai/tutorials/getting-started/serving-llms

Run this command in a terminal to start the Ollama inference server.

```bash
ollama serve  
```

--------------------------------

### Update System Packages

Source: https://docs.jarvislabs.ai/troubleshooting

Prepares the environment for CUDA installation by updating package lists and installing libxml2.

```bash
apt update  
export DEBIAN_FRONTEND=noninteractive  
apt-get install libxml2 -y  

```

--------------------------------

### Activate Virtual Environment

Source: https://docs.jarvislabs.ai/tutorials/getting-started/platform-overview

Activate the created virtual environment to begin installing packages.

```bash
source myenv/bin/activate  
```

--------------------------------

### Download CUDA Installer

Source: https://docs.jarvislabs.ai/troubleshooting

Downloads the specific CUDA toolkit installer from NVIDIA's repository.

```bash
wget https://developer.download.nvidia.com/compute/cuda/11.7.1/local  
_installers/cuda_11.7.1_515.65.01_linux.run  

```

--------------------------------

### Starting Runs on Fresh Instances

Source: https://docs.jarvislabs.ai/cli

Inline creation of a fresh instance for a single run using the --keep flag.

```bash
jl run . --script train.py --gpu L4 --keep --json --yes
```

--------------------------------

### Install PyTorch via uv

Source: https://docs.jarvislabs.ai/tutorials/getting-started/platform-overview

Install PyTorch and related libraries using uv, pointing to the official PyTorch CUDA index.

```bash
uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128  
```

--------------------------------

### Setup JarvisLabs CLI

Source: https://docs.jarvislabs.ai/cli

Configure the CLI with authentication and agent skills. Use flags to bypass interactive prompts.

```bash
# Interactive setup
jl setup

# Non-interactive, all skill paths (universal + Claude Code)
jl setup --token YOUR_TOKEN --agents all --yes

# Non-interactive, universal path only (skip Claude Code)
jl setup --token YOUR_TOKEN --agents universal
```

--------------------------------

### Launch Stable Diffusion web UI

Source: https://docs.jarvislabs.ai/automatic1111

Start the web UI manually with the xformers optimization flag.

```bash
python /home/stable-diffusion-webui/launch.py --xformers  
```

--------------------------------

### Install Node.js and Configure Docker Permissions

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Installs Node.js 22 and adds the ubuntu user to the docker group to enable non-sudo Docker execution.

```bash
# Install Node.js 22  
jl exec <machine_id> -- sh -lc '  
  curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - \  
  && sudo apt-get install -y nodejs \  
  && node --version \  
  && npm --version  
'  
  
# Add ubuntu user to docker group (avoids needing sudo for docker)  
jl exec <machine_id> -- sh -lc '  
  sudo usermod -aG docker ubuntu  
'  
```

--------------------------------

### Run FastAPI Server

Source: https://docs.jarvislabs.ai/tutorials/running-flux2-klein

Starts the FastAPI server for programmatic access to the model.

```bash
uv run flux2_fastapi_server.py  
```

```bash
uv run flux2_fastapi_server.py --model 9b  
```

--------------------------------

### Run scripts directly on a fresh GPU

Source: https://docs.jarvislabs.ai/cli

Automates instance creation, code upload, dependency installation, and execution in a single command.

```bash
# One-time setup  
jl setup  
  
# Check your balance and make sure you're good to go  
jl status  
  
# See which GPUs are currently available and their pricing  
jl gpus  
  
# Run a single training script on a fresh L4  
# Creates instance, uploads train.py, installs requirements, runs it, pauses when done  
jl run train.py --gpu L4 --requirements requirements.txt -- --epochs 50  
  
# Or if you have a project directory, sync the whole thing  
# This uploads your directory, creates a venv, installs deps, and runs the entrypoint  
jl run . --script train.py --gpu A100 --requirements requirements.txt  
  
# You can also run a setup command before your main command  
jl run . --script train.py --gpu A100 \
  --requirements requirements.txt \
  --setup "pip install flash-attn"  
  
# The CLI streams logs by default. Once the run finishes, the instance is auto-paused.  
# If you detached (Ctrl+C) or used --no-follow, you can check logs anytime:  
jl run logs <run_id> --tail 50  
  
# Check the final status of your run  
jl run status <run_id>
```

--------------------------------

### Run websocket API script

Source: https://docs.jarvislabs.ai/comfyui

Execute the websocket API example script using Python.

```bash
python websockets_api_example.py
```

--------------------------------

### Launch and Connect to VM via CLI

Source: https://docs.jarvislabs.ai/vm

Create a new virtual machine with specific GPU and storage requirements, then connect via SSH.

```bash
jl create --vm --gpu H100 --region EU1 --storage 100  
jl ssh <machine_id>  
```

--------------------------------

### Manage Jarvislabs via CLI

Source: https://docs.jarvislabs.ai/

Install the CLI tool, authenticate, and execute training scripts on GPU instances.

```bash
# Install, authenticate, and run a training script on a fresh GPU — all in one go  
uv tool install jarvislabs  
jl setup  
jl run train.py --gpu A100 --requirements requirements.txt
```

--------------------------------

### Create an instance with a startup script and filesystem

Source: https://docs.jarvislabs.ai/sdk

Uploads a startup script, creates a persistent filesystem, and launches an instance with both resources attached. Note that script_id must be cast to a string when passed to the create method.

```python
from jarvislabs import Client  
  
with Client() as client:  
    # Upload a startup script that installs your dependencies  
    client.scripts.add(  
        script="#!/bin/bash\npip install wandb tensorboard",  
        name="install-deps",  
    )  
  
    # Find the script ID by name  
    scripts = client.scripts.list()  
    script_id = next(s.script_id for s in scripts if s.script_name == "install-deps")  
  
    # Create a persistent filesystem for your datasets  
    fs_id = client.filesystems.create(fs_name="datasets", storage=200)  
  
    # Launch an instance with the startup script and filesystem attached  
    # Note: script_id must be passed as a string  
    inst = client.instances.create(  
        gpu_type="A100",  
        storage=100,  
        name="training",  
        script_id=str(script_id),  
        fs_id=fs_id,  
    )  
    print(f"Instance {inst.machine_id} is running")  
    print(f"SSH: {inst.ssh_command}")
```

--------------------------------

### Run projects with dependency management

Source: https://docs.jarvislabs.ai/cli

Examples of running scripts with automatic dependency detection or overriding with custom requirements files.

```bash
# Auto-detect (recommended for most projects)  
jl run . --script train.py --gpu L4  
  
# Override with a custom file  
jl run . --script train.py --gpu L4 --requirements custom-reqs.txt  
  
# Single file with requirements  
jl run train.py --gpu L4 --requirements requirements.txt
```

--------------------------------

### Format dataset with instruction templates

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-llms

Applies an instruction template and appends the EOS token to each dialogue example in the dataset.

```python
def format_example(example):  
    prompt = f"""Summarize the following conversation in one sentence.  
  
Conversation:  
{example['dialogue']}  
  
Summary:  
{example['summary']}{tokenizer.eos_token}"""  
    return {"text": prompt}  
  
dataset = dataset.map(format_example)  
print("Sample formatted:")  
print(dataset[0]["text"][:800])
```

--------------------------------

### Add a startup script

Source: https://docs.jarvislabs.ai/cli

Upload a shell script to be executed automatically upon instance launch.

```bash
jl scripts add ./setup.sh --name "install-deps"  
```

--------------------------------

### Get instance details

Source: https://docs.jarvislabs.ai/cli

Retrieve specific information for an instance, including SSH access and endpoint URLs.

```bash
jl get 12345  
jl get 12345 --json  
```

--------------------------------

### Install CUDA Toolkit

Source: https://docs.jarvislabs.ai/troubleshooting

Executes the installer in silent mode to install the toolkit to a custom path.

```bash
sh cuda_11.7.1_515.65.01_linux.run --silent --toolkit --toolkitpath=/home/cuda_11.7  

```

--------------------------------

### Launch Automatic1111 with API

Source: https://docs.jarvislabs.ai/automatic1111

Commands to terminate existing sessions and start the Automatic1111 server with the API enabled.

```bash
tmux kill -t automatic  
cd /home/stable-diffusion-webui/  
python launch.py --xformers --api  

```

--------------------------------

### View Training Parameters Output

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-llms

Example output showing the number of trainable parameters after applying LoRA.

```text
Unsloth 2026.1.2 patched 28 layers with 28 QKV layers, 28 O layers and 28 MLP layers.  
trainable params: 40,370,176 || all params: 7,655,986,688 || trainable%: 0.5273  

```

--------------------------------

### Create GPU and CPU Instances

Source: https://docs.jarvislabs.ai/api

Launch new instances by specifying hardware requirements and configuration.

```python
# Launch CPU Instance  
instance: Instance = Instance.create('CPU',  
                            num_cpus=1,  
                            storage=25,  
                            name='cpu instance')  
  
# Launch GPU Instance  
instance: Instance = Instance.create('GPU',  
                            gpu_type='RTX6000Ada',  
                            num_gpus=1,  
                            storage=50,  
                            name='gpu instance')  
  

```

--------------------------------

### Add Startup Script

Source: https://docs.jarvislabs.ai/sdk

Uploads a new startup script from a string or a file.

```python
# From a string  
client.scripts.add(script="#!/bin/bash\npip install wandb", name="install-deps")  
  
# From a file  
with open("setup.sh", "rb") as f:  
    client.scripts.add(script=f.read(), name="setup")  
```

--------------------------------

### List startup scripts

Source: https://docs.jarvislabs.ai/cli

Display all available startup scripts with their IDs and names.

```bash
jl scripts list  
jl scripts list --json  
```

--------------------------------

### Verify NemoClaw Installation

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Checks that the CLI is correctly installed and accessible in the system path.

```bash
jl exec <machine_id> -- sh -lc 'nemoclaw help'
```

--------------------------------

### Initialize and use the JarvisLabs Client

Source: https://docs.jarvislabs.ai/sdk

Demonstrates both context manager and manual lifecycle management for the Client instance.

```python
from jarvislabs import Client  
  
# With context manager (recommended)  
with Client(api_key="...") as client:  
    instances = client.instances.list()  
  
# Without context manager  
client = Client()  
instances = client.instances.list()  
client.close()  
```

--------------------------------

### Create a new GPU instance

Source: https://docs.jarvislabs.ai/cli

Provision a new container or VM instance. The command blocks until the instance is running.

```bash
# Basic instance  
jl create --gpu L4  
  
# H100 with more storage and a name  
jl create --gpu H100 --storage 200 --name "training-box"  
  
# With a startup script and filesystem  
jl create --gpu A100 --script-id 42 --fs-id 10  
  
# Pin to a region (EU1 supports H100 and H200)  
jl create --gpu H100 --region EU1  
  
# Expose HTTP ports  
jl create --gpu L4 --http-ports "7860,8080"  
  
# VM instance (requires SSH key - add one first with jl ssh-key add)  
jl create --gpu A100-80GB --vm --name "my-vm"  
  
# Non-interactive  
jl create --gpu L4 --yes --json  
```

--------------------------------

### scripts.add()

Source: https://docs.jarvislabs.ai/sdk

Uploads a new startup script.

```APIDOC
## scripts.add(script: bytes | bytearray | str, name: str = "")

### Description
Uploads a new startup script. You can pass the script content as a string directly, or read bytes from a file.

### Parameters
- **script** (bytes | bytearray | str) - Required - Script content
- **name** (str) - Optional - Script name (default: "")

### Returns
- **bool** - True on success.

### Errors
- **ValidationError** - Raised if the script content is empty.
```

--------------------------------

### Initialize UFW Firewall

Source: https://docs.jarvislabs.ai/vm

Configure basic UFW policies and enable the firewall.

```bash
sudo ufw allow ssh  
# Alternative if using custom SSH port  
# sudo ufw allow 2222/tcp  
```

```bash
sudo ufw default deny incoming  
sudo ufw default allow outgoing  
```

```bash
sudo ufw enable  
```

```bash
sudo ufw status verbose  
```

--------------------------------

### List Framework Templates

Source: https://docs.jarvislabs.ai/cli

List available templates for instance creation.

```bash
jl templates
jl templates --json
```

--------------------------------

### Launch and Configure JarvisLabs VM

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Commands to check GPU availability, create a VM instance, and rename it for easier management.

```bash
# Check what's available  
jl gpus --json  
  
# Create a VM (not a container — NemoClaw needs Docker inside the instance)  
jl create --gpu A100-80GB --vm --storage 100 --region IN2 --yes --json
```

```bash
# Rename for easy identification  
jl rename <machine_id> --name "nemoclaw-tutorial" --yes --json
```

--------------------------------

### scripts.list()

Source: https://docs.jarvislabs.ai/sdk

Returns all your saved startup scripts.

```APIDOC
## scripts.list()

### Description
Returns all your saved startup scripts.

### Returns
- **list[StartupScript]** - A list of objects containing:
  - **script_id** (int) - Unique script identifier
  - **script_name** (str | None) - Script name
```

--------------------------------

### Manage persistent filesystems

Source: https://docs.jarvislabs.ai/sdk

Demonstrates creating a filesystem, attaching it to an instance, and re-attaching it to a new instance after destruction.

```python
from jarvislabs import Client  
  
with Client() as client:  
    # Create a 500 GB filesystem for your datasets  
    fs_id = client.filesystems.create(fs_name="datasets", storage=500)  
  
    # Create an instance and attach the filesystem  
    inst = client.instances.create(  
        gpu_type="A100",  
        fs_id=fs_id,  
        name="training",  
    )  
    print(f"Filesystem mounted - upload your data via SSH: {inst.ssh_command}")  
  
    # ... train your model, save checkpoints to the filesystem ...  
  
    # Destroy the instance - the filesystem and its data persist  
    client.instances.destroy(inst.machine_id)  
  
    # Later, create a new instance with the same filesystem  
    # Your datasets and checkpoints are still there  
    inst = client.instances.create(  
        gpu_type="L4",  
        fs_id=fs_id,  
        name="inference",  
    )  
    print(f"Same data, different GPU: {inst.ssh_command}")
```

--------------------------------

### Install NemoClaw CLI

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Clones the repository, performs the required two-stage TypeScript build, and installs the package globally.

```bash
jl exec <machine_id> -- sh -lc '  
  cd /home/ubuntu \
  && git clone https://github.com/NVIDIA/NemoClaw.git \
  && cd NemoClaw \
  && npm install typescript \
  && npx tsc -p tsconfig.src.json \
  && cd nemoclaw \
  && npm install --ignore-scripts \
  && ./node_modules/.bin/tsc \
  && cd .. \
  && sudo npm install -g .  
'
```

--------------------------------

### Install Flux 2 dependencies

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-flux

Installs the specific requirements for DreamBooth training and ensures the Pillow library is up to date.

```bash
cd examples/dreambooth  
pip install -r requirements_flux.txt  
pip install --upgrade Pillow  
```

--------------------------------

### Install Specific PyTorch Version

Source: https://docs.jarvislabs.ai/troubleshooting

Installs a specific version of PyTorch, torchvision, and torchaudio compatible with CUDA 11.7.

```bash
pip install torch==1.13.0+cu117 torchvision==0.14.0+cu117  
torchaudio==0.13.0 --extra-index-url https://download.pytorch.org/whl/cu117  

```

--------------------------------

### Create a filesystem

Source: https://docs.jarvislabs.ai/cli

Initializes a new persistent storage volume with a specified name and size.

```bash
# Defaults to IN2  
jl filesystem create --name "datasets" --storage 200  
  
# Explicit region pin  
jl filesystem create --name "datasets" --storage 200 --region IN2  
```

--------------------------------

### Install Jupyter Kernel

Source: https://docs.jarvislabs.ai/tutorials/getting-started/platform-overview

Install the ipykernel package and register the environment to make it available in the Jupyter notebook kernel list.

```bash
uv pip install ipykernel  
python -m ipykernel install --user --name=my-env --display-name "Python3.12"  
```

--------------------------------

### List GPU instances

Source: https://docs.jarvislabs.ai/cli

Display all instances with their status and configuration details.

```bash
jl list  
jl list --json  
```

--------------------------------

### Install custom node dependencies

Source: https://docs.jarvislabs.ai/comfyui

Run this command within the node directory to install required Python packages if a requirements.txt file is present.

```bash
cd  ComfyUI_IPAdapter_plus  
pip install -r requirements.txt  
```

--------------------------------

### Example Output

Source: https://docs.jarvislabs.ai/tutorials/getting-started/serving-llms

Expected output format from the chat completion request.

```text
Machine learning is a method of teaching computers to recognize patterns in data and make predictions or decisions without being explicitly programmed.  
```

--------------------------------

### Get Billing Currency

Source: https://docs.jarvislabs.ai/sdk

Returns the billing currency associated with the account.

```python
currency = client.account.currency()  
print(f"Billing currency: {currency}")  

```

--------------------------------

### Agent Workflow End-to-End

Source: https://docs.jarvislabs.ai/cli

Complete lifecycle for GPU instance creation, job execution, monitoring, and cleanup.

```bash
# 1. Check GPU availability  
jl gpus --json  
  
# 2. Create an instance  
jl create --gpu L4 --storage 50 --yes --json  
# returns {"machine_id": 12345, ...}  
  
# 3. Start a detached run  
jl run . --script train.py --on 12345 --requirements requirements.txt --yes --json  
# returns {"run_id": "r_abc123", ...}  
  
# 4. Early failure check - catches crashes fast  
sleep 15 && jl run logs r_abc123 --tail 30  
  
# 5. If still running, poll at steady intervals (repeat until footer shows exit code)  
sleep 120 && jl run logs r_abc123 --tail 50  
  
# 6. Download results  
jl download 12345 /home/results ./results -r  
  
# 7. Clean up  
jl pause 12345 --yes --json
```

--------------------------------

### Check CUDA Version

Source: https://docs.jarvislabs.ai/tutorials/getting-started/platform-overview

Display the current CUDA version installed on the instance.

```bash
nvidia-smi  
```

--------------------------------

### Configure Accelerate

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-flux

Initialize the accelerate environment for training.

```bash
accelerate config
```

--------------------------------

### Model Inference Output

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-llms

Example output generated by the model after the fine-tuning process.

```text
After finetuning:  
#Person2# helps John Smith book a table for two around 7 PM tomorrow.
```

--------------------------------

### Enable Shell Completion

Source: https://docs.jarvislabs.ai/cli

Install tab completion for bash, zsh, and fish shells.

```bash
jl --install-completion
```

--------------------------------

### client.instances.create(...)

Source: https://docs.jarvislabs.ai/sdk

Creates a new GPU instance and blocks until it is fully provisioned and ready for use.

```APIDOC
## client.instances.create(...)

### Description
Creates a new GPU instance and blocks until it's fully running. By the time this method returns, the instance is ready to use.

### Parameters
- **gpu_type** (str) - Required - GPU type (e.g., "A100", "H100").
- **num_gpus** (int) - Optional (Default: 1) - Number of GPUs.
- **template** (str) - Optional (Default: "pytorch") - Framework template.
- **storage** (int) - Optional (Default: 40) - Storage in GB.
- **name** (str) - Optional (Default: "Name me") - Instance name (max 40 chars).
- **disk_type** (str) - Optional (Default: "ssd") - Disk type.
- **http_ports** (str) - Optional - Comma-separated HTTP ports to expose.
- **script_id** (str) - Optional - Startup script ID.
- **script_args** (str) - Optional - Arguments for the startup script.
- **fs_id** (int) - Optional - Filesystem ID to attach.
- **arguments** (str) - Optional - Additional arguments.
- **region** (str) - Optional - Region code ("IN1", "IN2", or "EU1").

### Returns
- **Instance** - The fully provisioned instance.

### Raises
- **ValidationError** - If parameters are invalid.
- **APIError** - If instance creation fails.
```

--------------------------------

### Run FastAPI with Uvicorn

Source: https://docs.jarvislabs.ai/deploy/fastapi

Start the FastAPI application server on a specific host and port.

```bash
uvicorn main:app --host 0.0.0.0 --port 6006
```

--------------------------------

### Run Training Script

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-flux

Download the training script and execute it with the specified memory optimizations and hyperparameters.

```bash
curl -O https://raw.githubusercontent.com/huggingface/diffusers/db37140474a4f14955a4450a2a171fe987b4c8f5/examples/dreambooth/train_dreambooth_lora_flux2.py  
  
accelerate launch train_dreambooth_lora_flux2.py \
  --pretrained_model_name_or_path="black-forest-labs/FLUX.2-dev" \
  --dataset_name="multimodalart/1920-raider-waite-tarot-public-domain" \
  --output_dir="flux2-tarot-lora" \
  --do_fp8_training \
  --gradient_checkpointing \
  --remote_text_encoder \
  --cache_latents \
  --instance_prompt="in tarot card art style" \
  --resolution=1024 \
  --train_batch_size=1 \
  --guidance_scale=1 \
  --use_8bit_adam \
  --gradient_accumulation_steps=4 \
  --learning_rate=1e-4 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=100 \
  --max_train_steps=500 \
  --validation_prompt="a cat sitting on a throne in tarot card art style" \
  --validation_epochs=50 \
  --report_to="wandb" \
  --seed=0
```

--------------------------------

### Example log output

Source: https://docs.jarvislabs.ai/cli

The format of raw logs when not using the --json flag.

```text
--- run r_abc123 | machine 12345 | running ---

step=100 loss=2.31
step=200 loss=2.11

--- still running | log: /home/jl-runs/r_abc123/output.log ---
```

--------------------------------

### Service endpoint output

Source: https://docs.jarvislabs.ai/dstack

Example output showing the published service and model endpoints.

```text
Service is published at:  
  http://localhost:3000/proxy/services/main/qwen3-rtx-pro-6000/  
Model Qwen/Qwen3-8B is published at:  
  http://localhost:3000/proxy/models/main/  
```

--------------------------------

### Manage Kaggle datasets

Source: https://docs.jarvislabs.ai/downloaddata

Commands for downloading, initializing, creating, and updating datasets on Kaggle.

```bash
kaggle competitions download -c feedback-prize-2021  
```

```bash
kaggle datasets init -p /path/to/dataset  
```

```bash
kaggle datasets create -p /path/to/dataset  
```

```bash
kaggle datasets version -p /path/to/dataset -m "Updated data"  
```

--------------------------------

### Activate a Conda environment

Source: https://docs.jarvislabs.ai/environment

Activate the environment to install libraries or initialize the shell if activation fails.

```bash
conda activate /home/myenv/  
```

```bash
conda init bash  
source .bashrc  
```

--------------------------------

### client.account.templates()

Source: https://docs.jarvislabs.ai/sdk

Lists available framework templates for creating instances.

```APIDOC
## client.account.templates()

### Description
Returns the list of available framework templates you can use when creating an instance (e.g. pytorch, tensorflow, jax, vm).

### Returns
- **id** (str) - Template identifier
- **title** (str) - Display name
- **description** (str | None) - Template description
- **category** (str | None) - Category grouping
- **versions** (str | None) - Available versions
```

--------------------------------

### Deploy and Verify vLLM

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Launches a vLLM container with the Qwen 2.5 7B model and provides commands to verify the service status and test inference.

```bash
jl exec <machine_id> -- sh -lc '  
  sg docker -c "docker run -d \  
    --gpus all \  
    --name vllm \  
    -p 8000:8000 \  
    --shm-size 16g \  
    vllm/vllm-openai:latest \  
    --model Qwen/Qwen2.5-7B-Instruct"  
'  
```

```bash
# Check vLLM logs (look for "Application startup complete")  
jl exec <machine_id> -- sh -lc '  
  sg docker -c "docker logs vllm 2>&1 | tail -5"  
'  
  
# Test inference  
jl exec <machine_id> -- sh -lc '  
  curl -s http://localhost:8000/v1/chat/completions \  
    -H "Content-Type: application/json" \  
    -d "{  
      \"model\": \"Qwen/Qwen2.5-7B-Instruct\",  
      \"messages\": [{\"role\": \"user\", \"content\": \"Hello, who are you?\"}],  
      \"max_tokens\": 50  
    }"  
'  
```

--------------------------------

### Connect to VM and Verify GPU

Source: https://docs.jarvislabs.ai/host-ai-model

Commands to access the instance via SSH and confirm GPU availability.

```bash
jl ssh <machine_id>  
```

```bash
nvidia-smi  
```

--------------------------------

### Create Filesystem

Source: https://docs.jarvislabs.ai/sdk

Initialize a new filesystem with a specified name and storage capacity. Region defaults to IN2 if not explicitly provided.

```python
# Defaults to IN2  
fs_id = client.filesystems.create(fs_name="datasets", storage=200)  
  
# Explicit region pin  
fs_id = client.filesystems.create(fs_name="datasets", storage=200, region="IN2")  
print(f"Created filesystem: {fs_id}")
```

--------------------------------

### Run the Flask server

Source: https://docs.jarvislabs.ai/deploy/flask-api

Execute these commands in the terminal to start the Flask application on port 6006.

```bash
export FLASK_APP=hello  
flask run --host=0.0.0.0 --port=6006
```

--------------------------------

### Access API endpoint

Source: https://docs.jarvislabs.ai/automatic1111

Example curl command to query the available models via the API.

```bash
curl "API_ENDPOINT/sdapi/v1/sd-models"  

```

--------------------------------

### Configure and Run SFTTrainer

Source: https://docs.jarvislabs.ai/tutorials/getting-started/finetuning-llms

Initializes the SFTTrainer with specific training hyperparameters and executes the training process.

```python
from trl import SFTTrainer, SFTConfig  
  
trainer = SFTTrainer(  
    model=model,  
    processing_class=tokenizer,  
    train_dataset=dataset,  
    args=SFTConfig(  
        per_device_train_batch_size=4,  
        gradient_accumulation_steps=4,  
        warmup_steps=50,  
        max_steps=500,  
        learning_rate=2e-4,  
        logging_steps=25,  
        optim="adamw_8bit",  
        seed=42,  
        output_dir="outputs",  
        dataset_text_field="text",  
        max_length=2048,  
    ),  
)  
  
print("Starting training...")  
trainer.train()  
print("Training complete!")
```

--------------------------------

### Get Instance Details

Source: https://docs.jarvislabs.ai/sdk

Fetches information for a specific instance using its unique machine ID.

```python
inst = client.instances.get(12345)  
print(f"{inst.name}: {inst.status}")
```

--------------------------------

### client.filesystems.create()

Source: https://docs.jarvislabs.ai/sdk

Creates a new persistent filesystem with a specified name and storage capacity.

```APIDOC
## client.filesystems.create(fs_name, storage, *, region=None, deployment_id=None)

### Description
Creates a new filesystem with the given name and size. The returned ID is used to attach the filesystem to instances.

### Parameters
- **fs_name** (str) - Required - Filesystem name (max 30 characters).
- **storage** (int) - Required - Storage in GB (50–2048).
- **region** (str) - Optional - Region pin: `IN1` or `IN2`; defaults to `IN2`. Keyword-only.
- **deployment_id** (str) - Optional - Optional deployment ID to associate. Keyword-only.

### Returns
- **int** - The new filesystem ID.
```

--------------------------------

### GET /deployment/{deployment_id}/{request_id}

Source: https://docs.jarvislabs.ai/serverless

Polls for the result of an asynchronous request using the request ID.

```APIDOC
## GET /deployment/{deployment_id}/{request_id}

### Description
Polls the status of an asynchronous request. Returns 202 while processing, or the completion object once ready.

### Method
GET

### Endpoint
https://<region-base-url>/deployment/{deployment_id}/{request_id}

### Parameters
#### Path Parameters
- **deployment_id** (string) - Required - The unique identifier for the deployment.
- **request_id** (string) - Required - The ID returned from the submit request.
```

--------------------------------

### Run Gradio App with 9B Model

Source: https://docs.jarvislabs.ai/tutorials/running-flux2-klein

Starts the Gradio application specifically configured for the 9B model.

```bash
uv run flux2_gradio_app.py --model 9b  
```

--------------------------------

### Download files and directories

Source: https://docs.jarvislabs.ai/cli

Retrieve files or directories from a running instance to the local machine.

```bash
# Download a file (saves to ./results.csv)
jl download 12345 /home/results.csv

# Download to a specific local path
jl download 12345 /home/results.csv ./my-results.csv

# Download a directory
jl download 12345 /home/outputs ./local-outputs -r
```

--------------------------------

### Launch ComfyUI Server

Source: https://docs.jarvislabs.ai/comfyui

Starts the ComfyUI main script on port 6006 with external access enabled.

```bash
python ComfyUI/main.py --port 6006 --listen 0.0.0.0  
```

--------------------------------

### Connect to the Agent

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Initiate a connection to the sandboxed agent environment.

```bash
nemoclaw my-assistant connect  
```

--------------------------------

### Run Model with Ollama

Source: https://docs.jarvislabs.ai/tutorials/getting-started/serving-llms

Execute this command to download and interact with the Qwen2.5-7B model.

```bash
ollama run qwen2.5:7b  
```

--------------------------------

### NemoClaw Dashboard Output

Source: https://docs.jarvislabs.ai/tutorials/nemoclaw-on-jarvislabs

Example of the status dashboard displayed upon successful completion of the onboarding process.

```text
  ──────────────────────────────────────────────────  
  Sandbox      my-assistant (Landlock + seccomp + netns)  
  Model        vllm-local (Local vLLM)  
  NIM          not running  
  ──────────────────────────────────────────────────  
  Run:         nemoclaw my-assistant connect  
  Status:      nemoclaw my-assistant status  
  Logs:        nemoclaw my-assistant logs --follow  
  ──────────────────────────────────────────────────
```
Tokens:
Raw