Skip to content
Back to search

lepton-skills

MarketplaceWorks with Claude CodeGitHub

Agent skills for operating NVIDIA DGX Cloud Lepton.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/leptonai/leptonai with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/leptonai/leptonai'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/leptonai--leptonai/badge.svg)](/listings/leptonai--leptonai)

HTML

<a href="/listings/leptonai--leptonai"><img src="/api/listings/leptonai--leptonai/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install the library, which also installs the `lep` command-line tool:

pip install -U leptonai

To install the latest development version from the `main` branch (requires Git):

pip install -U "git+https://github.com/leptonai/leptonai.git@main"

Log in to your workspace (this opens a browser to fetch credentials if you don't pass them in):

lep login

Deploy a container image as an endpoint, then inspect it:

lep endpoint create -n my-endpoint --container-image my-registry/my-app:latest
lep endpoint list
lep endpoint status -n my-endpoint

In workspaces with secure endpoint defaults enabled, an endpoint created without `--tokens` is protected automatically. The create command prints the generated API token; save that value so clients can authenticate. You can instead provide one or more repeatable `--tokens` values, or explicitly opt out with `--allow-unauthenticated-access` (the CLI displays a warning). The `--public` option only controls IP reachability and does not disable API-token authentication. `lep endpoint status` reports these dimensions separately as `IP Access` and `API Token Authentication`.

SDK callers that leave endpoint authentication unspecified should use `client.deployment.create_with_response(...)` and save the token from the returned resource. The older `create(...)` method keeps its boolean return contract and cannot return a server-generated credential, so it emits a `RuntimeWarning` for requests that may ask the server to generate one. SDK updates may not clear `api_tokens` by sending an empty list alone: set `allow_unauthenticated_access=true` in the same update, or replace the list with at least one token.

`lep endpoint get` redacts literal tokens by default. Use `--show-tokens` only when you need a credential-bearing response or reusable spec export, and handle that output as a secret. The former hidden `update --remove-tokens` option is rejected; use `--allow-unauthenticated-access` for an explicit opt-out.

Authentication-mode updates are explicit:

# Replace tokens and enable token authentication
lep endpoint update -n my-endpoint --tokens MY_TOKEN

# Clear tokens and explicitly allow requests without API-token authentication
lep endpoint update -n my-endpoint --allow-unauthenticated-access

You can also launch batch jobs and dev pods:

# Run a batch job
lep job create -n my-job --container-image my-registry/my-trainer:latest --command "python train.py"

# Launch an interactive dev pod
lep pod create -n my-pod --resource-shape gpu.a10

# Open a shell in the pod through the workspace API (no SSH setup needed)
lep pod shell -n my-pod

# Connect to a pod with Teleport SSH enabled (requires local tsh)
lep pod ssh -n my-pod --transport teleport

`lep pod shell`, `lep endpoint shell`, `lep job shell`, and `lep raycluster shell` open the same interactive shell as the dashboard terminal. The session is tunnelled through the workspace API over HTTPS, so it needs no SSH key, public IP, or Teleport client. They follow the dashboard's rules: a pod must be Ready and opens in its newest replica, an endpoint or job with several running replicas requires `--replica`, archived jobs and platform-managed tuning jobs have no shell, and a Ray cluster shell opens on the head node of a cluster that is not stopped unless `--replica` selects another node. Idle shells send a keepalive so the workspace ingress does not close them.

Teleport SSH commands require `tsh` v18 or newer in your PATH. The CLI checks the client version before reading login profiles or starting SSO; missing, older, or unrecognized clients produce an actionable error. This minimum version check does not guarantee compatibility with every Teleport cluster version.

Teleport SSH reuses your local Teleport login, or starts SSO login when needed. As in the dashboard, legacy Pods and Slurm Dev Pods sign in with the `Starfleet`

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "lepton-skills",
  3. "description": "Agent skills for operating NVIDIA DGX Cloud Lepton.",
  4. "owner": {
  5. "name": "Lepton AI"
  6. },
  7. "plugins": [
  8. {
  9. "name": "lepton-cli",
  10. "source": "./plugins/lepton-cli",
  11. "description": "Operate NVIDIA DGX Cloud Lepton through the globally installed `lep` CLI.",
  12. "version": "0.1.0"
  13. }
  14. ]
  15. }
README.md · README · 316 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <img src="https://raw.githubusercontent.com/leptonai/leptonai/main/assets/logo.svg" height=100>
  2. # Lepton AI
  3. **The Python library and `lep` CLI for NVIDIA DGX Cloud Lepton**
  4. <a href="https://docs.nvidia.com/dgx-cloud/lepton">Homepage</a> •
  5. <a href="https://github.com/leptonai/examples">Examples</a> •
  6. <a href="https://docs.nvidia.com/dgx-cloud/lepton">Documentation</a> •
  7. <a href="https://docs.nvidia.com/dgx-cloud/lepton/reference/cli/get-started/">CLI References</a>
  8. The LeptonAI Python library lets you operate the [NVIDIA DGX Cloud Lepton](https://docs.nvidia.com/dgx-cloud/lepton) platform from Python and the command line. Key features include:
  9. - A `lep` command-line tool to create and manage endpoints, Dynamo graph deployments, batch jobs, dev pods, Ray clusters, fine-tuning jobs, storage, secrets, and more, plus inspect managed Slurm clusters and jobs.
  10. - Pythonic configuration specs that are readily shipped to the cloud.
  11. - Skills that let agents operate the Lepton platform for you.
  12. ## Getting started
  13. Install the library, which also installs the `lep` command-line tool:
  14. ```shell
  15. pip install -U leptonai
  16. ```
  17. To install the latest development version from the `main` branch (requires Git):
  18. ```shell
  19. pip install -U "git+https://github.com/leptonai/leptonai.git@main"
  20. ```
  21. Log in to your workspace (this opens a browser to fetch credentials if you don't pass them in):
  22. ```shell
  23. lep login
  24. ```
  25. Deploy a container image as an endpoint, then inspect it:
  26. ```shell
  27. lep endpoint create -n my-endpoint --container-image my-registry/my-app:latest \
  28. --resource-shape gpu.a10 --node-group my-node-group
  29. lep endpoint list
  30. lep endpoint status -n my-endpoint
  31. ```
  32. In workspaces with secure endpoint defaults enabled, an endpoint created without
  33. `--tokens` is protected automatically. The create command prints the generated API
  34. token; save that value so clients can authenticate. You can instead provide one or
  35. more repeatable `--tokens` values, or explicitly opt out with
  36. `--allow-unauthenticated-access` (the CLI displays a warning). The `--public` option
  37. only controls IP reachability and does not disable API-token authentication.
  38. `lep endpoint status` reports these dimensions separately as `IP Access` and
  39. `API Token Authentication`.
  40. SDK callers that leave endpoint authentication unspecified should use
  41. `client.deployment.create_with_response(...)` and save the token from the returned
  42. resource. The older `create(...)` method keeps its boolean return contract and cannot
  43. return a server-generated credential, so it emits a `RuntimeWarning` for requests that
  44. may ask the server to generate one. SDK updates may not clear `api_tokens` by sending
  45. an empty list alone: set `allow_unauthenticated_access=true` in the same update, or
  46. replace the list with at least one token.
  47. `lep endpoint get` redacts literal tokens by default. Use `--show-tokens` only when you
  48. need a credential-bearing response or reusable spec export, and handle that output as
  49. a secret. The former hidden `update --remove-tokens` option is rejected; use
  50. `--allow-unauthenticated-access` for an explicit opt-out.
  51. Authentication-mode updates are explicit:
  52. ```shell
  53. # Replace tokens and enable token authentication
  54. lep endpoint update -n my-endpoint --tokens MY_TOKEN
  55. # Clear tokens and explicitly allow requests without API-token authentication
  56. lep endpoint update -n my-endpoint --allow-unauthenticated-access
  57. ```
  58. You can also launch batch jobs and dev pods:
  59. ```shell
  60. # Run a batch job
  61. lep job create -n my-job --container-image my-registry/my-trainer:latest --command "python train.py" \
  62. --resource-shape gpu.a10 --node-group my-node-group
  63. # Launch an interactive dev pod
  64. lep pod create -n my-pod --resource-shape gpu.a10 --node-group my-node-group
  65. # Open a shell in the pod through the workspace API (no SSH setup needed)
  66. lep pod shell -n my-pod
  67. # Connect to a pod with Teleport SSH enabled (requires local tsh)
  68. lep pod ssh -n my-pod --transport teleport
  69. ```
  70. `lep pod shell`, `lep endpoint shell`, `lep job shell`, and `lep raycluster shell`
  71. open the same interactive shell as the dashboard terminal. The session is
  72. tunnelled through the workspace API over HTTPS, so it needs no SSH key, public
  73. IP, or Teleport client. They follow the dashboard's rules: a pod must be Ready
  74. and opens in its newest replica, an endpoint or job with several running
  75. replicas requires `--replica`, archived jobs and platform-managed tuning jobs
  76. have no shell, and a Ray cluster shell opens on the head node of a cluster that
  77. is not stopped unless `--replica` selects another node. Idle shells send a
  78. keepalive so the workspace ingress does not close them.
  79. Teleport SSH commands require `tsh` v18 or newer in your PATH. The CLI checks
  80. the client version before reading login profiles or starting SSO; missing, older,
  81. or unrecognized clients produce an actionable error. This minimum version check
  82. does not guarantee compatibility with every Teleport cluster version.
  83. Teleport SSH reuses your local Teleport login, or starts SSO login when needed.
  84. The authentication connector is selected automatically; use
  85. `--teleport-auth <connector>` to choose one. Lepton API credentials and Teleport
  86. login are separate. Your workspace
  87. (`dev_pod_teleport`), node group, and pod must have Teleport enabled, and the
  88. pod must be Ready.
  89. Pod SSH uses the server's Teleport connection details when available. Otherwise,
  90. as for Jobs below, it uses the active `tsh` profile or
  91. `--teleport-proxy <host>:443` and connects as `root` to the pod's
  92. `<workspace-id>-<pod-name>` node. If no profile is selected, provide
  93. `--teleport-proxy` to start login. Omit this option when the server provides the
  94. proxy. Without `--transport teleport`, `lep pod ssh` uses direct SSH.
  95. If you do not know which proxy to use, ask your workspace or node group
  96. administrator for the Teleport proxy (`host[:port]`) and, if required, the SSO
  97. connector name. Replace the placeholders below with those values:
  98. ```shell
  99. tsh login --proxy=<proxy>
  100. # If your administrator specifies an SSO connector:
  101. tsh login --proxy=<proxy> --auth=<connector>
  102. ```
  103. Complete the sign-in steps shown by `tsh`, then rerun your `lep ... ssh` command.
  104. Alternatively, pass `--teleport-proxy <proxy>` to `lep pod ssh --transport teleport`
  105. or `lep job ssh` to start sign-in automatically; add `--teleport-auth <connector>`
  106. if needed. The CLI selects the SSH target and Linux account for you. That Linux
  107. account (such as `root`) is separate from the identity you use to sign in to
  108. Teleport. If access is denied, ask your administrator to verify your access to
  109. the workload.
  110. Jobs can also be accessed through Teleport when their workspace has `job_teleport`
  111. enabled and their image/entrypoint starts a Teleport agent:
  112. ```shell
  113. lep job replicas --id <job-id>
  114. lep job ssh --id <job-id> --replica <replica-id>
  115. # Or select a uniquely named job (a single ready replica is selected automatically)
  116. lep job ssh --name <job-name>
  117. # Specify the proxy when you have not logged in, or to switch from another proxy
  118. lep job ssh --id <job-id> --replica <replica-id> --teleport-proxy <host>:443
  119. ```
  120. Job SSH defaults to the active `tsh` profile because the Job API does not publish
  121. Teleport connection details. It uses the standard Lepton agent's
  122. `<workspace-id>-<replica-id>` hostname and workspace label to find one node, then
  123. connects to its Teleport node ID as `root`. Historical and unready replicas are
  124. excluded; multiple ready replicas require `--replica`. The job must be Running
  125. or Starting. Job SSH does not install the agent or change the workload's startup
  126. command. Use `--teleport-auth` to choose an SSO connector.
  127. Slurm compute nodes also support Teleport SSH:
  128. ```shell
  129. lep node list-nodes --node-group <node-group>
  130. lep node ssh --node-group <node-group-name-or-id> --id <node-id>
  131. ```
  132. Node SSH discovers the Slurm cluster, Teleport proxy, Machine hostname, and Linux
  133. account automatically, so it never needs `--teleport-proxy`. When needed, the
  134. CLI runs `tsh login` for you as the user who owns your Lepton API token, so
  135. Service Account Tokens are not supported; that user needs workspace user or
  136. admin access. The compute group must enable Teleport and use host networking. For
  137. clusters using Pod Networking, use `lep slurm job ssh` on a running Slurm job
  138. you own instead. The session opens in the compute container; Slurm account
  139. permissions and job allocation policies still apply. Use `--teleport-auth` to
  140. override the SSO connector.
  141. For a workspace with managed Slurm, inspect clusters and jobs:
  142. ```shell
  143. lep slurm cluster list --name prod --status Ready
  144. lep slurm cluster shell -n production
  145. lep slurm job list --cluster production --status Running --include-archived
  146. lep slurm job attempts -i 12345 --steps
  147. lep slurm job log -n my-training-job --follow
  148. lep slurm devpod get --cluster production
  149. lep slurm devpod ssh --cluster production
  150. ```
  151. Login nodes, running jobs, and Dev Pods can also be reached through Teleport:
  152. ```shell
  153. lep slurm cluster ssh -n production
  154. lep slurm job ssh -i 12345 --node <allocated-node>
  155. lep slurm devpod ssh --cluster production --transport teleport
  156. ```
  157. Like `lep node ssh`, these find the Teleport proxy from the Slurm cluster and
  158. sign in to Teleport as the user who owns your Lepton API token. Login-node and
  159. job SSH connect as your Slurm Linux account, derived from your email by the
  160. cluster's LDAP mapping. Login-node SSH requires a Ready cluster with Teleport
  161. enabled for its login nodes; `--node` picks a login node other than the first.
  162. Job SSH requires a running job owned by your Slurm account; a job on several
  163. nodes requires `--node`. Dev Pod SSH uses the Teleport node and Linux account
  164. the Dev Pod reports. If Teleport access is denied, ask your Slurm cluster
  165. administrator to verify it.
  166. Personal Slurm Dev Pods are available under `lep slurm devpod`; run
  167. `lep slurm --help` for the complete command tree. `devpod get` shows the
  168. effective configuration, identity, connection details, and dashboard link;
  169. `devpod ssh` runs the bastion command reported by the platform unless
  170. `--transport teleport` is given. Slurm job
  171. submission and cancellation remain native Slurm operations (`sbatch`, `squeue`,
  172. `scancel`) on the cluster rather than Lepton API mutations.
  173. Dynamo graph deployments (multi-service LLM inference with a vLLM, SGLang, or
  174. TensorRT-LLM backend) have their own command group. Each `-svc` block configures
  175. one service; the frontend is required and workers inherit its node group:
  176. ```shell
  177. lep dynamo create -n my-dynamo --framework vllm \
  178. -svc frontend --resource-shape cpu.small --node-group my-node-group \
  179. -svc worker --resource-shape gpu.h100-80gb --replicas 2 -e MODEL=Qwen/Qwen3-0.6B
  180. lep dynamo status -n my-dynamo
  181. lep dynamo replica log -n my-dynamo -s worker --tail 200
  182. lep dynamo update -n my-dynamo -svc worker --replicas 4
  183. ```
  184. Dynamo 1.3.1 multi-node workers are configured with `--node-count`; `--replicas`
  185. counts independent worker groups. vLLM, SGLang and TensorRT-LLM accept aggregated
  186. and disaggregated configurations:
  187. ```shell
  188. lep dynamo create -n my-multi --framework vllm \
  189. -svc frontend --resource-shape cpu.small --node-group my-node-group \
  190. -svc worker --resource-shape gpu.h100-80gb --node-count 2
  191. lep dynamo create -n my-pd --framework vllm --serving-mode disaggregated \
  192. -svc frontend --resource-shape cpu.small --node-group my-node-group \
  193. -svc prefill-worker --resource-shape gpu.h100-80gb --node-count 2 \
  194. -svc decode-worker --resource-shape gpu.h100-80gb --node-count 2
  195. lep dynamo create -n my-trt --framework trtllm \
  196. -svc frontend --resource-shape cpu.small --node-group my-node-group \
  197. -svc worker --resource-shape gpu.h100-80gb --node-count 2
  198. lep dynamo update -n my-multi --dry-run -svc worker --node-count 4
  199. ```
  200. Choose shapes available in your group. Default commands derive GPU parallelism
  201. from the selected shape; unknown or fractional GPU counts require an explicit
  202. `--command`. Updates synchronize recognized default commands with changed
  203. parallelism and protect custom commands.
  204. Run `lep --help`, or `lep <command> --help` for any subcommand, to explore everything. See the [CLI references](https://docs.nvidia.com/dgx-cloud/lepton/reference/cli/get-started/) for the full guide.
  205. ## Checking out more examples
  206. You can find more examples in the [examples repository](https://github.com/leptonai/examples), and full guides in the [documentation](https://docs.nvidia.com/dgx-cloud/lepton).
  207. ## Skills: Operating Lepton from Claude Code or Codex
  208. This repo ships an [agent skill](plugins/lepton-cli/skills/lepton-cli/SKILL.md) that lets [Claude Code](https://claude.com/claude-code) (or Codex) drive the `lep` CLI for you — listing endpoints, inspecting jobs and dev pods, checking workspace status, and managing workloads, all from natural language. It uses the same `lep` CLI installed above, so make sure it is authenticated to your workspace.
  209. The plugin lives under [plugins/lepton-cli](plugins/lepton-cli) with per-agent manifests for Claude Code, Codex, and Cursor (`.claude-plugin/`, `.codex-plugin/`, `.cursor-plugin/`), all sharing the one skill at [skills/lepton-cli](plugins/lepton-cli/skills/lepton-cli). It is listed in two marketplaces in this repo: [.claude-plugin/marketplace.json](.claude-plugin/marketplace.json) for Claude Code and [.agents/plugins/marketplace.json](.agents/plugins/marketplace.json) for Codex.
  210. **Codex** — add this repo as a marketplace, then install the plugin:
  211. ```text
  212. codex plugin marketplace add leptonai/leptonai
  213. codex plugin add lepton-cli@lepton-skills
  214. ```
  215. Or browse interactively: run `/plugins` in the Codex CLI (or open **Plugins** in the Codex app), find **Lepton CLI**, and install.
  216. **Claude Code** — install from the Lepton marketplace in one line, nothing to clone:
  217. ```text
  218. /plugin marketplace add leptonai/leptonai
  219. /plugin install lepton-cli@lepton-skills
  220. ```
  221. Start a new session, then ask something like *"List the endpoints in my Lepton workspace."* The skill asks for explicit confirmation before any command that modifies or deletes a workload.
  222. <details>
  223. <summary><b>Codex, or Claude Code without plugins</b></summary>
  224. Clone this repo, then copy the skill into your agent's skills directory:
  225. ```bash
  226. # Codex
  227. cp -R plugins/lepton-cli/skills/lepton-cli "${CODEX_HOME:-$HOME/.codex}/skills/lepton-cli"
  228. # Claude Code (personal skill)
  229. cp -R plugins/lepton-cli/skills/lepton-cli "$HOME/.claude/skills/lepton-cli"
  230. ```
  231. Restart the agent afterward.
  232. </details>
  233. ## Contributing
  234. This repository uses [uv](https://docs.astral.sh/uv/) to manage its Python environment and dependencies. After installing uv, run these commands from the repository root:
  235. ```shell
  236. uv sync --locked
  237. uv run lep --help
  238. ```
  239. This installs the local source and development tools into `.venv`, using the Python version in `.python-version` and the dependencies in `uv.lock`. Use `uv run lep` to run the CLI without activating the environment.
  240. Contributions and collaborations are welcome and highly appreciated. Please check out the [contributor guide](https://github.com/leptonai/leptonai/blob/main/CONTRIBUTING.md) for how to get involved.
  241. ## License
  242. The Lepton AI Python library is released under the Apache 2.0 license.
  243. Developer Note: early development of LeptonAI was in a separate mono-repo, which is why you may see commits from the `leptonai/lepton` repo. We intend to use this open source repo as the source of truth going forward.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.