Announcing dell-ai v1.0: A CLI and SDK to interact with Dell Enterprise Hub

Discover and run open-source AI models and applications on Dell hardware through the Dell Enterprise Hub.

---

The open-source frontier models landscape is moving faster than ever. Every week new reasoning, coding and multimodal models are released. For teams running AI on-premises, the real challenge is not just finding a model, but also turning it into an optimized deployment that can serve their needs on the exact Dell PowerEdge or Pro Max configuration they own. With dell-ai v1.0, the Dell Enterprise Hub (DEH) gets a programmable control plane. It is not just an API client: it is an opinionated workflow that discovers validated models and platforms, generates production-ready Docker, Kubernetes or Helm snippets, sizes them for real workloads, executes them on your local node, and keeps track of what is running.

This post walks through the architecture and the key capabilities of dell-ai on its v1.0. For each feature, we will explain not only what it does, but what it means for you when operating AI on premises.

Table of contents

• TL;DR
• Getting started in 60 seconds
• Why an SDK/CLI for DEH?
• The 30,000-foot architecture
• 1. Discovery: models, platforms, and apps
• 2. Snippet generation
• 3. Local deployment and resource management
• 4. Goodput scenarios
• 5. Environment variables
• 6. Deployment registry
• 7. System utilities
• 8. Agent skills
• Conclusion and references

TL;DR

• dell-ai v1.0 is a Python SDK and CLI that talks to the Dell Enterprise Hub.
• It discovers validated models, platforms, and applications, generates deployment snippets and allows users to execute them locally using Docker, Kubernetes, or Helm.
• Goodput scenarios let DEH choose the right GPU count and runtime parameters for a workload profile, so you stop guessing vLLM flags.
• Automatic resource management picks free host ports and free GPU indices, including support for both NVIDIA and AMD accelerators.
• A deployment registry tracks endpoints, container IDs, and assigned GPUs, so you can list and tear down deployments days later.
• Scoped environment variables and system utilities make the tool predictable in shared environments and on validated Dell stacks.
• An agent skill lets assistants such as Devin, Cursor, Claude Code, and OpenCode drive dell-ai from natural language.

Getting started in 60 seconds

From installation to a ready endpoint, dell-ai gets you up and running in just a few commands. The following example shows how install the CLI, authenticate, deploy and manage your first model:

# 1. Install
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv .venv
source .venv/bin/activate
uv pip install dell-ai

# 2. Authenticate (uses your Hugging Face token)
dell-ai login
dell-ai whoami

# 3. Find and deploy a model
dell-ai models list --format table
dell-ai models deploy \
  -m meta-llama/Llama-4-Maverick-17B-128E-Instruct \
  -p xe9680-nvidia-h200 \
  -e docker -g 8 -r 1

# 4. Check and tear down
dell-ai status
dell-ai models undeploy -d meta-llama/Llama-4-Maverick-17B-128E-Instruct

In case you want to use dell-ai programmatically, the Python SDK mirrors the CLI:

from dell_ai.client import DellAIClient

client = DellAIClient()

snippet = client.get_deployment_snippet(
    model_id="meta-llama/Llama-4-Maverick-17B-128E-Instruct",
    platform_id="xe9680-nvidia-h200",
    engine="docker",
    num_gpus=8,
    num_replicas=1,
)

result = client.deploy_model(
    model_id="meta-llama/Llama-4-Maverick-17B-128E-Instruct",
    platform_id="xe9680-nvidia-h200",
    engine="docker",
    num_gpus=8,
    num_replicas=1,
    detach=True,
)
print(result["success"], result.get("endpoint"), result.get("container_id"))

Why an SDK/CLI for DEH?

Browsing the DEH website is great for exploration, but production workflows need repeatability. Platform engineers want to script deployments. Data scientists want to spin up a model from a notebook. Agentic tools want a compact, deterministic surface to call.

dell-ai provides that surface. It exposes the DEH catalog as typed Pydantic objects, turns selection into validated commands, and then bridges the gap between "the snippet on the screen" and "the container on the GPU." The result is a single tool that handles:

In short, dell-ai turns the DEH catalog into an on-prem operations workflow.

The 30,000-foot architecture

At its core, dell-ai is a thin but full-of-functionallity layer between the DEH REST API and your local node. It is built in Python, uses pydantic v2 for validation, typer for the CLI, and requests for HTTP.

┌───────────────────────┐      HTTPS      ┌───────────────────────────────┐
│   dell-ai CLI / SDK   │  ◄────────────► │  Dell Enterprise Hub API      │
│                       │                 │  /models, /skus, /snippets,   │
└──────────┬────────────┘                 │  /apps, /goodput-scenarios    │
           │                              └───────────────────────────────┘
           │
           ▼
┌──────────────────────────────────────┐
│   DellAIClient                       │
│   - auth via huggingface_hub         │
│   - session + error translation      │
│   - loads env on init                │
└──────────────┬───────────────────────┘
               │
               ├──► models / platforms / apps / goodput  (catalog & snippets)
               ├──► deployments / resources              (local execution)
               ├──► env                                  (scoped config)
               └──► system_utils                         (node introspection)
               │
               ▼
┌────────────────────────────────────────────┐
│   Local node                               │
│   docker, kubectl, helm, nvidia-smi,       │
│   rocm-smi, lscpu, lsblk, dmidecode        │
└────────────────────────────────────────────┘

The two primary entry points are the Typer CLI (dell-ai) and the DellAIClient Python class. Both call the same underlying modules, so anything you can do in the CLI you can script in Python. This matters because it lets CI pipelines, notebooks, and agents use the exact same code path.

---

1. Discovery: models, platforms, and apps

What it is

dell-ai exposes the DEH catalog as three searchable collections:

• Models: open-source checkpoints with per-SKU deployment configs and container tags.
• Platforms: validated Dell hardware SKUs, including GPU vendor, accelerator, and interconnect details.
• Applications: ready-to-deploy Helm charts such as Open WebUI.

You can list, search, filter, and inspect each one. For models, you can also list compatible platforms, check gated-repo access, and pin specific container image tags.

What it means for you

You no longer maintain a side spreadsheet of "what runs on XE9680-H200." The catalog is the source of truth, and every entry is already validated by Dell and Hugging Face. For gated models, dell-ai checks your Hugging Face token before you waste time generating a snippet you cannot pull.

In practice

# See everything
 dell-ai models list --format table
 dell-ai platforms list --format table
 dell-ai apps list --format table

# Drill into a model and its compatible SKUs
 dell-ai models show meta-llama/Llama-4-Maverick-17B-128E-Instruct
 dell-ai models compatible-platforms google/gemma-3-27b-it --format table

# Available image tags for this model/platform pair
 dell-ai models list-tags \
   -m meta-llama/Llama-4-Maverick-17B-128E-Instruct \
   -p xe9680-nvidia-h200

2. Snippet generation

What it is

A snippet is a ready-to-run deployment command: a docker run, a Kubernetes manifest, or a helm install. dell-ai fetches the correct snippet from DEH for a given model, platform, engine, and sizing mode. It validates that the model exists, that you have access, and that the platform/GPU configuration is supported.

What it means for you

You stop hand-editing long container commands from blog posts. The snippet is produced from the DEH-validated config for your exact SKU, and dell-ai can further pin the container image tag, mount local weights, or inject a Hugging Face cache path.

In practice

# Manual GPU sizing
 dell-ai models get-snippet \
   -m meta-llama/Llama-4-Maverick-17B-128E-Instruct \
   -p xe9680-nvidia-h200 \
   -e docker \
   -g 8 -r 1

# Pin a specific image tag and mount local Hugging Face cache
 dell-ai models get-snippet \
   -m meta-llama/Llama-4-Maverick-17B-128E-Instruct \
   -p xe9680-nvidia-h200 \
   -e docker -g 8 \
   --image-tag vllm-v0.11.2 \
   --hf-cache-dir ~/.cache/huggingface

# App snippet (Helm)
 dell-ai apps get-snippet openwebui \
   --config '{"config":[{"helmPath":"main.config.storageClassName","type":"string","value":"gp2"}]}'

3. Local deployment and resource management

What it is

dell-ai does not stop at generating a snippet, it can actually run it. For Docker, it remaps the host port to a free one if the preferred port is taken, allocates free GPU indices, and pins the container to those devices. It supports both NVIDIA (--gpus) and AMD (/dev/dri/renderD*) backends. For Kubernetes it applies the manifest with kubectl, and for applications it runs helm.

What it means for you

You can go from "I want this model" to "it is running on localhost" in a single command, without manual port bookkeeping or GPUmanagement. Running the same model twice creates separate suffixed deployment IDs, each with its own port and GPU set, so experiments do not step on each other.

In practice

# Docker, detached (default)
 dell-ai models deploy \
   -m meta-llama/Llama-4-Maverick-17B-128E-Instruct \
   -p xe9680-nvidia-h200 \
   -e docker -g 8 -r 1

# Kubernetes
 dell-ai models deploy \
   -m meta-llama/Llama-4-Maverick-17B-128E-Instruct \
   -p xe9680-nvidia-h200 \
   -e kubernetes -g 8 -r 1

# Use local weights instead of downloading from the Hub
 dell-ai models deploy \
   -m meta-llama/Llama-4-Maverick-17B-128E-Instruct \
   -p xe9680-nvidia-h200 \
   -e docker -g 8 \
   --local-dir /data/my-model

4. Goodput scenarios

What it is

A model "running" is not the same as a model "running well." DEH goodput scenarios define workload profiles such as balanced, long-context, high-concurrency, and performance, each with service-level objectives (SLOs). When you pass --goodput to dell-ai, the DEH backend returns a snippet sized for that profile on the chosen platform.

What it means for you

You stop guessing how many GPUs or what context length a workload needs. Instead, you describe the workload and the tool returns a sizing that meets the SLO. This is especially useful for agentic coding, RAG, and chat workloads where peak benchmark throughput does not translate to real user experience.

In practice

# Inspect the available scenarios and per-SKU targets
 dell-ai models goodput-scenarios --format table
 dell-ai models goodput-scenarios --platform-idsku xe9680-nvidia-h100 --format table

# Generate or deploy using a scenario
 dell-ai models get-snippet \
   -m google/gemma-3-27b-it \
   -p xe9680-nvidia-h100 \
   -e docker \
   --goodput balanced

 dell-ai models deploy \
   -m google/gemma-3-27b-it \
   -p xe9680-nvidia-h100 \
   -e docker \
   --goodput balanced

dell-ai enforces that --gpus and --goodput are mutually exclusive. You must choose manual sizing or scenario-based sizing, never both.

5. Environment variables

What it is

dell-ai persists environment variables in two scopes: a local .dell-ai-env.json file in the current directory, and a global ~/.config/dell-ai/env.json file. They are automatically loaded into os.environ when the CLI starts or when a DellAIClient is created. Precedence is shell → local → global.

What it means for you

Project-specific settings can live in the repo (without committing secrets), while personal defaults follow you across directories. Common uses include DELL_AI_CHECKPOINT paths and custom DELL_AI_API_BASE_URL endpoints for testing. Values with TOKEN, SECRET, KEY, or PASSWORD in the key are masked when listed.

In practice

 dell-ai env set DELL_AI_CHECKPOINT /data/checkpoints
 dell-ai env set DELL_AI_ENDPOINT http://localhost:80 --global
 dell-ai env get DELL_AI_CHECKPOINT
 dell-ai env list
 dell-ai env delete DELL_AI_CHECKPOINT

6. Deployment registry

What it is

Successful deployments are recorded in a JSON registry. The local scope lives in .dell-ai-deployments.json, the global scope in ~/.config/dell-ai/deployments.json. Each entry stores the deployment ID, endpoint, engine, container ID or K8s deployment name, assigned GPUs, and a timestamp. The registry also auto-discovers running DEH Docker containers and prunes stale entries.

What it means for you

You can close your terminal, go home, and still come back on Monday knowing exactly what is serving on port 8087 and which GPUs it owns. dell-ai status combines the registry with live probes, checkpoint checks, and docker/kubectl scans. dell-ai models undeploy stops the underlying resource and removes the registry entry.

In practice

# See everything that is running
dell-ai status

# Clean up exited containers and stopped K8s deployments
dell-ai status --clean

# Teardown one deployment by its ID
dell-ai models undeploy -d meta-llama/Llama-4-Maverick-17B-128E-Instruct

7. System utilities

What it is

dell-ai utils describe-system returns a structured JSON profile of the current Linux node: CPU, memory, storage, OS, GPU, driver, and Kubernetes information. dell-ai utils check-system compares that profile against the DEH-validated configurations for the matching Dell platform and reports mismatches.

What it means for you

You find out whether a node is actually DEH-compatible before pulling a 100 GB container image. It turns "why does my vLLM deployment fail?" into a proactive check: missing driver, wrong GPU count, unsupported kernel, etc.

In practice

 dell-ai utils describe-system -o /tmp/sysinfo.json
 dell-ai utils check-system

The command relies on standard Linux tools: lscpu, lspci, lsblk, dmidecode, nvidia-smi / rocm-smi, and kubectl.

8. Agent skills

What it is

The repository ships an agent skill at skills/dell-ai/SKILL.md. It is a compact prompt that teaches assistants such as Devin, Cursor, Claude Code, Codex, and OpenCode how to use dell-ai for model discovery, snippet generation, deployment, status checks, and teardown. The dell-ai skills add command symlinks the skill into the assistant's skill directory.

What it means for you

You can ask an agent in plain English: "Deploy Qwen3-Coder-Next on my XE9680-H200 with the balanced goodput scenario and then check the status." The agent has the exact command shapes, validation rules, and registry conventions it needs to run the workflow end to end.

In practice

# Install the skill for Devin in this project
 dell-ai skills add dell-ai --dest .devin/skills

# Or for Cursor globally
 dell-ai skills add dell-ai --cursor --global

# View the skill
 dell-ai skills show dell-ai

Conclusion and references

dell-ai v1.0 bridges the gap between the DEH catalog and an operational on-prem AI stack. It turns model selection into a validated, repeatable workflow: discover, size, generate, deploy, track, and tear down. The CLI is for terminal users, the SDK is for scripts and CI, and the agent skill is for the next generation of AI-assisted operations.

• dell-ai GitHub repository.