Setup

Install NeMo Platform and start working with AI agents.

Prerequisites

• Python 3.11-3.14
• An API key from one of: NVIDIA Build, OpenAI, Anthropic, Google Gemini, or a local Ollama instance (no key needed)
• 16 GB available disk space and 8 GB RAM
• For the PyPI install: pip in a Python environment
• For the source checkout install: Git, GNU Make, uv, Node.js (≥22.18.0, <23) satisfying web/package.json, and pnpm

Install

Choose the install path that matches what you want to do.

Install from PyPI

Use the PyPI package for the quickest local install. The all extra includes the SDK, CLI, platform services, and default first-party plugins:

$
python -m venv .venv
$
source .venv/bin/activate
$
pip install "nemo-platform[all]"

On Python 3.14, prefix the install command with PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 while the transitive litellm Rust extension catches up to Python 3.14:

$
PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 pip install "nemo-platform[all]"

For SDK and CLI usage only, install the base package:

$
pip install nemo-platform

After installing nemo-platform[all] from PyPI, continue with nemo setup.

Install from source

Use the source checkout when you are contributing to NeMo Platform, editing local plugins, building Studio assets from source, or running development workflows:

$
git clone https://github.com/NVIDIA-NeMo/nemo-platform.git
$
cd nemo-platform
$
make bootstrap
$
source .venv/bin/activate

The make bootstrap target creates the Python environment, syncs Python dependencies, builds Studio assets, and installs local plugins.

If Studio asset bootstrap fails, the API can still run but Studio is unavailable until the web bundle is built. Install Node.js with pnpm using pnpm env use --global 22.18.0, then rerun make bootstrap-studio from the repository root.

Verify the installation:

$
nemo --help

Set up the platform

$
nemo setup

The wizard walks through each stage:

1. Start services — launches the platform locally
2. Choose a provider — select your model provider and enter your API key
3. Register the provider — connects the provider to the platform
4. Discover models — finds available models from your provider
5. Set a default model — pick the model to use by default
6. Install skills — adds NeMo skills to detected coding agents (Cursor, Claude Code, Codex)
7. Deploy agent — optionally deploys a demo calculator agent on the platform

Each stage is idempotent — you can re-run nemo setup at any time to add more providers or update your configuration.

Auth and OIDC source installs

nemo setup and nemo services run do not create authorization role bindings by themselves. If you enable auth in source config with auth.enabled: true and set auth.admin_email, run the platform seed task so the bootstrap IAM bindings exist.

For local single-process source runs, enable startup seeding before starting services:

$
export NMP_SEED_ON_STARTUP=true
$
nemo services run

You can set platform.seed_on_startup: true in platform config instead. If services are already running, wait for readiness and run the seed task manually from the repository root:

$
# Set NMP_BASE_URL first if services are not on http://localhost:8080.
$
curl -sf http://localhost:8080/health/ready
$
uv run python -m nmp.platform_seed

uv run nemo-platform run task --task nmp.platform_seed is equivalent. The seed task is idempotent. It creates the PlatformAdmin binding in the system workspace for auth.admin_email, the wildcard Editor binding for the default workspace, the wildcard Viewer binding for the system workspace, and the wildcard WorkspaceCreator binding for the system workspace. Without this step, OIDC login can succeed but admin operations may still return 403 Forbidden because the RBAC bindings are missing.

When setup completes, try chatting with the model you selected. Use the model name shown at the end of setup (or find it with nemo models list):

$
nemo chat <model-name>

Demo agent

If you accepted Deploy agent during setup, a demo calculator agent is running on the platform. Try it out:

$
nemo agents invoke --agent calculator-agent --input "What is 12 * 8?"

Coding agent skills

If you accepted Install skills during setup and use Cursor, Claude Code, or Codex, your coding agent now has NeMo skills. Ask it to:

• “Help me optimize my agent” — invokes the nemo-agents-optimize skill which analyzes deployed agents, compares models, suggests improvements
• “Help me secure my agent” — invokes the nemo-agents-secure skill which runs audit scans, adds guardrails, flags vulnerabilities
• “Evaluate my model [model_name] for helpfulness of responses on the HuggingFace nvidia/HelpSteer2 dataset. Limit evaluation to 5 samples” — runs evaluation
• “Generate training data for [task]” — builds Data Designer configurations

Run nemo skills list to see which skills are installed for the current environment — the agent can only invoke what’s in that list.

Supported providers

Ollama requires no API key but must be running before nemo setup. Start it with ollama serve.

Non-interactive setup

For CI pipelines, scripts, or automated environments, use --auto. Set one provider environment variable — the first match wins.

$
export OPENAI_API_KEY=sk-...
$
nemo setup --auto --start-services

Priority order: NEMO_DEFAULT_INFERENCE_KEY > NVIDIA_API_KEY > OPENAI_API_KEY > ANTHROPIC_API_KEY > GEMINI_API_KEY

Flags

Override the default model with NEMO_DEFAULT_MODEL:

$
export OPENAI_API_KEY=sk-...
$
export NEMO_DEFAULT_MODEL=default/openai-gpt-4.1
$
nemo setup --auto --start-services

Examples

$
# Full automation: services, skills, and agent
$
export NVIDIA_API_KEY=nvapi-...
$
nemo setup --auto --start-services --install-skills --deploy-agent
$
$
# Provider only (platform already running)
$
export OPENAI_API_KEY=sk-...
$
nemo setup --auto
$
$
# Skip skills and agent
$
nemo setup --no-install-skills --no-deploy-agent

What to explore next

Python SDK

The nemo-platform package includes a Python SDK. After running nemo setup, the simplest initialization uses your CLI context:

1
from nemo_platform import NeMoPlatform
2
3
client = NeMoPlatform()

For scripts or CI where you want explicit control:

1
import os
2
from nemo_platform import NeMoPlatform
3
4
client = NeMoPlatform(
5
    base_url=os.environ.get("NMP_BASE_URL", "http://localhost:8080"),
6
    workspace="default",
7
)

An asynchronous client is also available. See the SDK reference for details.

Troubleshooting

Platform won’t start

Check ~/.local/state/nmp/instances/<scope>/services.log in the directory where you ran nemo setup. The most common cause is port 8080 already in use.

Studio returns 404 or unavailable

Studio requires the FastAPI web assets built by make bootstrap-studio. If make bootstrap warned that Studio asset bootstrap did not complete, install Node.js with pnpm using pnpm env use --global 22.18.0, then rerun make bootstrap-studio and nemo services restart from the repository root.

No models discovered

The provider may still be syncing. Wait 30 seconds and run nemo models list. If still empty, verify your API key is valid and the provider endpoint is reachable.

”Platform not reachable” error

Start services explicitly:

$
nemo setup --start-services

Or start them in a separate terminal:

$
nemo services run

Re-running setup

nemo setup is idempotent. Existing secrets, providers, and agent deployments are detected and skipped. Run it again to add a second provider or re-attempt a stage that failed.

Managing services

$
nemo services ls              # running instances only
$
nemo services ls --all        # include stopped instance directories (with logs on disk)
$
nemo services rm <scope>      # remove one stopped instance directory
$
nemo services prune           # remove all stopped instance directories
$
curl -s http://localhost:8080/health/ready   # check if running
$
cat ~/.local/state/nmp/instances/<scope>/services.log   # view service output
$
nemo services stop            # stop the running instance for this scope

Stopped instance directories cluttering ls --all

After stopping or crashing local services, stopped scope directories can remain under ~/.local/state/nmp/instances/<scope>/. Empty lock-only ghosts are cleaned automatically; directories with service logs stay until you remove them:

$
nemo services ls --all        # see stopped scopes
$
nemo services logs --instance <scope>   # inspect logs before removing
$
nemo services rm <scope>      # remove one stopped instance directory
$
nemo services prune           # remove all stopped instance directories