Skip to main content
skill CX Codex

nemo-relay-migrate-from-flow — Claude Code skill: NeMo Flow migration

nemo-relay-migrate-from-flow — a skill that automates code, documentation, and config migration from NeMo Flow to NeMo Relay. Handles Python, Rust, Node.js, Go, C FFI, CLI, and observability surfaces.

Apache-2.0 171 installs ★ 4,106 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add NVIDIA/skills --skill nemo-relay-migrate-from-flow -a claude-code
Open on GitHub

What nemo-relay-migrate-from-flow does

This skill renames package identifiers, import paths, and environment variables across a codebase moving from NeMo Flow to NeMo Relay. It rewrites imports in Rust (nemo_flow:: to nemo_relay::), updates Node.js package names and entry points, changes Go module paths, replaces C FFI headers and macro prefixes, and modifies CLI config paths and environment variables like NEMO_FLOW_*.

Migration starts in dry-run mode: the bundled migrate_from_nemo_flow.py script reports all proposed edits and path renames, then applies them only after your confirmation. The script skips lockfiles (regenerate these with Cargo, pip, or npm), leaves local .nemo-flow/config.toml and .nemo-flow/plugins.toml untouched—you move those to a supported config path manually.

After migration, the skill verifies the result: searches for remaining Flow references, runs tests for each affected language, and rebuilds documentation if install commands or repository links changed.

What it helps with

  • rename Python imports from nemo_flow to nemo_relay across the entire project
  • update Rust crate paths and rewrite use statements to nemo_relay::
  • change Node.js package names and entry points in package.json
  • update Go import paths and migrate go/nemo_flow directory structure
  • replace C FFI header names, type prefixes, and macro constants

Example prompts for the agent

  • Migrate my project from NeMo Flow to NeMo Relay and show me all the changes first
  • Run the migration on my Python and Rust code in /path/to/project, then list what will change
  • Update docs and examples to replace NeMo Flow references with NeMo Relay

How to install nemo-relay-migrate-from-flow

1Skills CLI (Vercel)

npx skills add NVIDIA/skills --skill nemo-relay-migrate-from-flow -a claude-code

2Manually: put the files in place

~/.claude/skills/nemo-relay-migrate-from-flow/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/nemo-relay-migrate-from-flow/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about nemo-relay-migrate-from-flow

How do I install nemo-relay-migrate-from-flow in Claude Code?

Run npx skills add NVIDIA/skills --skill nemo-relay-migrate-from-flow -a claude-code, then reference ~/.claude/skills/nemo-relay-migrate-from-flow/SKILL.md. For other platforms, use the appropriate flag: -a codex for Codex, -a cursor for Cursor, -a gemini-cli for Gemini CLI.

What does the nemo-relay-migrate-from-flow skill do?

It renames all NeMo Flow identifiers to NeMo Relay across imports, package names, directory paths, header files, macros, and environment variables. Runs in dry-run mode first to show changes before applying them.

Do I need to manually update lockfiles and config after migration?

Yes. Regenerate lockfiles (Cargo.lock, package-lock.json, go.sum) using your package manager. The skill does not touch .nemo-flow/config.toml or .nemo-flow/plugins.toml—move those manually to your supported config path.

Source text

SKILL.md · Apache-2.0
---
name: nemo-relay-migrate-from-flow
description: Use this skill when migrating applications, examples, integrations, documentation, manifests, or repository code from NeMo Flow to NeMo Relay across Python, Rust, Node.js, Go, C FFI, CLI, configuration, and observability surfaces.
license: Apache-2.0
metadata:
  author: NVIDIA Corporation and Affiliates
---

# Migrate From NeMo Flow To NeMo Relay

Use this skill when a user has existing NeMo Flow code or documentation and
wants it converted to NeMo Relay. Treat the migration as a mechanical rename
plus language-specific validation, not a behavior rewrite.
Keep compatibility exceptions explicit before applying broad renames.

## Default Workflow

1. Inspect the working tree and identify touched surfaces: Rust, Python,
   Node.js, Go, C FFI, CLI/config, docs, or integrations.
2. Resolve `SKILL_DIR` to the absolute directory containing this `SKILL.md` and
   `TARGET_PATH` to the source repository or target project. Run the bundled
   helper in dry-run mode before editing:
   `python3 "$SKILL_DIR/scripts/migrate_from_nemo_flow.py" "$TARGET_PATH" --rename-paths`
3. Review the reported text edits, path renames, and legacy project
   configuration warnings with the user. Do not migrate project-local
   `.nemo-flow/config.toml` or `.nemo-flow/plugins.toml` into `.nemo-relay`.
   Move those settings manually to a supported user or explicit configuration
   path after review.
4. Obtain explicit confirmation for the resolved target root, then rerun with
   `--write`, `--rename-paths`, and `--confirm-root "$TARGET_PATH"`.
5. Apply language-specific cleanup for package manager lockfiles, generated
   artifacts, and public API examples.
6. Search for remaining Flow names and verify the affected language surfaces.

## Mechanical Rename Map

- Brand and repository: `NeMo Flow` -> `NeMo Relay`,
  `NeMo-Flow` -> `NeMo-Relay`
- Python: `nemo-flow` -> `nemo-relay`, `nemo_flow` -> `nemo_relay`,
  `python/nemo_flow` -> `python/nemo_relay`
- Rust: `nemo-flow` -> `nemo-relay`, `nemo-flow-adaptive` ->
  `nemo-relay-adaptive`, `nemo_flow::` -> `nemo_relay::`
- Node.js: `nemo-flow-node` -> `nemo-relay-node`, including related entry
  points such as `/typed`, `/plugin`, `/adaptive`, and `/observability`
- Go: `github.com/NVIDIA/NeMo-Flow/go/nemo_flow` ->
  `github.com/NVIDIA/NeMo-Relay/go/nemo_relay`, package aliases
  `nemo_flow` -> `nemo_relay`, and source directories `go/nemo_flow` ->
  `go/nemo_relay`
- C FFI: `nemo_flow.h` -> `nemo_relay.h`, `nemo_flow_*` ->
  `nemo_relay_*`, `NemoFlow*` -> `NemoRelay*`, and `NEMO_FLOW_*` ->
  `NEMO_RELAY_*`
- CLI/config: `nemo-flow` -> `nemo-relay`,
  `~/.config/nemo-flow` -> `~/.config/nemo-relay`, `NEMO_FLOW_*` ->
  `NEMO_RELAY_*`, and `x-nemo-flow-*` -> `x-nemo-relay-*`. Do not blindly
  rename project-local `.nemo-flow/config.toml` or `.nemo-flow/plugins.toml`
  into `.nemo-relay`; those files require manual migration to a supported user
  or explicit configuration path.

Do not replace bare `flow`, `Flow`, or `FlowError`. Those can be domain words
or intentional compatibility names.

## Language Cleanup

- **Python**: update `pyproject.toml`, imports, type stubs, integration
  package paths, extras, and native module names. Regenerate or refresh lockfiles
  with the user's package workflow after source edits.
- **Rust**: update `Cargo.toml` crate names, workspace dependencies, package
  references, and `use nemo_relay::...` imports. Let Cargo regenerate
  `Cargo.lock` when dependencies changed.
- **Node.js**: update `package.json`, workspace names, package-lock entries,
  native addon artifact names, and imports from `nemo-relay-node`. Run the
  package manager to refresh locks.
- **Go**: update `go.mod`, import paths, package declarations, aliases, and any
  local directory layout under `go/nemo_relay`.
- **C FFI**: update header includes, exported symbol names, status and callback
  type names, macro constants, loader paths, and downstream bindings.
- **Docs and examples**: update badges, package install commands, repository
  links, hosted docs URLs, CLI commands, config paths, and integration names.

## Automation Helper

Use `$SKILL_DIR/scripts/migrate_from_nemo_flow.py` for first-pass edits. The
helper:

- runs as a dry run unless `--write` is passed
- skips common vendor, build, cache, and generated directories
- skips lockfiles unless `--include-lockfiles` is passed
- skips symbolic links and credential-bearing dotenv files
- detects project-local `.nemo-flow/config.toml` and `.nemo-flow/plugins.toml`,
  leaves them unchanged, and reports that they require manual migration to a
  supported user or explicit configuration path
- requires the reviewed target root to be repeated with `--confirm-root` before
  writing, and refuses filesystem-root or home-directory writes
- anchors writes and renames to verified directory handles without following
  symbolic links, and refuses write mode on platforms that cannot provide those
  guarantees
- uses atomic no-replace path renames and exits nonzero when any requested
  mutation fails
- can report or perform path renames with `--rename-paths`
- rewrites only explicit NeMo Flow identifiers, package names, repository names,
  config paths, headers, environment variables, and FFI type prefixes

The helper does not classify arbitrary JSON, YAML, TOML, or INI files as secret.
Review every configuration file in the dry-run report. If any reported file is
unreviewed or credential-bearing, do not use `--write` on that root. Apply the
reviewed changes manually and leave secret-bearing files untouched without
reading or displaying their values.

Set shell-safe absolute paths before invoking the helper. Replace the example
values with the resolved skill directory and either the source repository or the
user's target project:

```bash
SKILL_DIR="/resolved/absolute/path/to/nemo-relay-migrate-from-flow"
TARGET_PATH="/resolved/absolute/path/to/target-project"

python3 "$SKILL_DIR/scripts/migrate_from_nemo_flow.py" "$TARGET_PATH" --rename-paths
python3 "$SKILL_DIR/scripts/migrate_from_nemo_flow.py" "$TARGET_PATH" \
  --write --rename-paths --confirm-root "$TARGET_PATH"
```

Use `--include-lockfiles` only when the user wants lockfiles edited directly;
otherwise regenerate them with Cargo, uv/pip, npm, or Go tooling.

## Verification

- Search for remaining explicit Flow identifiers:
  `rg -n "NeMo Flow|NeMo-Flow|nemo_flow|nemo-flow|NEMO_FLOW|NemoFlow|nemo_flow\\.h|nemo_flow_"`
- Run targeted tests for every affected language surface.
- For Rust changes, run `cargo test` or the repository's Rust test recipe.
- For Python changes, run the relevant import check and tests in the target
  environment.
- For Node.js changes, run package install, type checks, and package tests.
- For Go changes, run `go test ./...` from the updated module.
- For docs-only migrations, build or link-check docs if the site navigation,
  install commands, or API references changed.

## Related Skills

- `nemo-relay-get-started`
- `nemo-relay-instrument-calls`
- `nemo-relay-debug-runtime-integration`

© NVIDIA Corporation and Affiliates · Apache-2.0 · NVIDIA/skills

Similar skills

All skills for Code review and refactoring →

From the same set312

The whole set →
nemo-relay-debug-runtime-integration The nemo-relay-debug-runtime-integration skill traces NeMo Relay runtime faults across loading, scopes, events, plugins, and adaptive wiring. Use it when the package is present but app behavior is wrong. CX Codex +1 197installs nemo-relay-instrument-typed-wrappers nemo-relay-instrument-typed-wrappers configures NeMo Relay typed wrappers and provider codecs while keeping JSON middleware semantics intact. CX Codex +1 182installs nemo-relay-plugin-build nemo-relay-plugin-build is a skill for packaging reusable NeMo Relay behavior as config components or dynamic plugins, with validation and rollback for plugins shared across apps or teams. CX Codex +1 181installs nemo-relay-plugin-adaptive-tuning nemo-relay-plugin-adaptive-tuning is a Claude Code skill that configures and evaluates NeMo Relay adaptive behavior from runtime signals, including telemetry, parallelism, hints, and prompt-cache planning. CX Codex +1 178installs doca-bench This skill guides doca_bench runs to measure DOCA library performance on a host or BlueField Arm. Use it to check throughput or latency and record a baseline before changing a system. CX Codex +1 166installs nemo-relay-get-started The nemo-relay-get-started skill routes first-time NeMo Relay users to the right quick-start, then checks whether the initial integration actually works. CX Codex +1 163installs doca-debug doca-debug finds the failing DOCA layer, from installation and linking to runtime and drivers. Use it for unresolved symbols, DOCAERROR results, silent tools, and crashes. CX Codex +1 162installs doca-bf3-deployment doca-bf3-deployment is a skill for day-1 BlueField-3 provisioning over classic RShim/BFB, handling BFB image push, TMFIFO setup, DPU mode selection, and recovery. CX Codex +1 159installs

Project sponsors

Companies that keep this analytics open