NeMo Data Designer

Generate high-quality synthetic data from scratch or from your own seed data.

Stars
★ 2.3k
Last updated
2d ago
License
Apache-2.0
Primary language
Python

At a glance

How it runs
Library / SDKCLIAgent plugin / skill
Works with
Universal · cross-platformOpenAI API · Claude APIClaude Code (Partial support)
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
Python 3.10+API keys (NVIDIA Build, OpenAI, or OpenRouter)Shell / CLINetwork accessLocal filesystem
Typical use
Data scientists needing diverse training data for ML models when real data is scarce or sensitive.
Not a fit if
  • Teams planning to run NVIDIA Build endpoints in production
  • Production projects needing stable APIs and mature docs

What does this agent do, and when should you use it?

NeMo Data Designer is NVIDIA's framework for generating synthetic datasets, either from scratch or based on existing seed data. It provides statistical samplers, LLM text columns, dependency-aware generation, built-in validators (Python, SQL, and custom remote), and LLM-as-a-judge scoring. It supports preview mode for rapid iteration before full-scale generation. Installation is via pip, and it supports multiple model providers (NVIDIA Build, OpenAI, OpenRouter). The framework offers a Python API and CLI tools, and includes a skill for coding agents, enabling integration with tools like Claude Code.

NeMo Data Designer generates synthetic data through column configurations. Users define columns using SamplerColumnConfig and LLMTextColumnConfig, specifying sampler types (e.g., CATEGORY) and prompt templates. It uses an async engine to process columns concurrently and supports dependency-aware generation to control correlations between fields. Built-in validators (Python, SQL, remote) ensure data quality, and LLM-as-a-judge scores outputs. Users can preview datasets via the DataDesigner class's preview method and configure model providers via the data-designer config CLI. The framework also offers a CLI tool and a skill integration that enables coding agents (e.g., Claude Code) to generate datasets from natural language descriptions.

  1. Data scientists needing diverse training data for ML models when real data is scarce or sensitive.
  2. Engineers generating synthetic datasets with specific field correlations, such as customer data for testing database queries.
  3. Researchers creating annotated datasets quickly to evaluate LLM outputs.
  4. Developers building multi-language text datasets using LLM prompt templates for benchmarking.
  5. QA teams validating data integrity and business rules before data enters production.

How do you install or deploy this agent?

Install via pip: pip install data-designer. Or from source: git clone https://github.com/NVIDIA-NeMo/DataDesigner.git && cd DataDesigner && make install. Requires Python 3.10 to 3.14.

How do you use this agent?

Set one API key: export NVIDIA_API_KEY="..." or export OPENAI_API_KEY="..." or export OPENROUTER_API_KEY="...". In Python, import data_designer.config and DataDesigner, create a DataDesignerConfigBuilder, add column configs (e.g., SamplerColumnConfig or LLMTextColumnConfig), then call data_designer.preview(config_builder=config_builder) and preview a sample.

What are this agent's strengths and limitations?

Pros
  • Seamless support for multiple model providers (NVIDIA Build, OpenAI, OpenRouter) with no code changes.
  • Built-in validators (Python, SQL, remote) ensure generated data quality and business rule compliance.
  • Async engine improves performance on large datasets by parallelizing columns and adapting concurrency.
  • Preview mode and LLM-as-a-judge scoring enable rapid iteration before full-scale generation.
Limitations
  • Requires valid API keys (NVIDIA Build, OpenAI, or OpenRouter), which may incur costs.
  • Data privacy concerns when using NVIDIA Build endpoint; its terms of service may restrict production use.
  • The framework is still early-stage and may lack some documentation or stable APIs.
  • Skill integration is primarily aimed at Claude Code; support for other coding agents is limited.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
NeMo Data Designer This agent 49 · Major gaps Library / SDKFree + model costs ★ 2.3k 2d ago Python OpenAI API · Claude API
OpenBB Open Data Platform 37 · Major gaps Library / SDKFreemium ★ 74k today Python —
Wisp Science 71 · Some gaps Desktop appFree + model costs ★ 1k today Rust Codex · Claude Code · OpenAI API · Claude API
EDSL (Expected Parrot Domain-Specific Language) 63 · Some gaps Library / SDKFree + model costs ★ 507 1d ago Python OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
49/ 100 5-point scale 2.5 / 5
This review covers the source as of Aug 11, 2026. The project has shipped 5 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 11/29
Reliability 8/14
Adaptability 10/18
Convention 10/18
Effectiveness 7/13
Verifiability 3/8
Why each dimension lost points
Trust11 / 29 · 1.9/5

Evidence shows: README clearly states telemetry can be disabled (NEMO_TELEMETRY_ENABLED=false) and describes the data collected (model names and token counts), indicating data flow transparency. However, no clear evidence of least privilege, user confirmation, or rollback mechanisms. Dependency security: pyproject.toml comments mention security-fix versions (e.g., aiohttp, jupyter-server), showing some attention. External effects: README mentions configurable third-party endpoints but lacks detail. Source attribution: README provides citation info, but publisher identity is unverified. Deductions: lack of implementation details for least privilege, user confirmation, rollback, and sensitive data handling.

Reliability8 / 14 · 2.9/5

Evidence shows: Project structure is clear with multiple test files (e.g., fern/scripts/tests/), indicating good self-consistency. Dependency availability: pyproject.toml defines dependency groups but no full lockfile details (e.g., uv.lock). Failure messages: tests do not reveal explicit error handling or user-friendly failure messages. Deductions: insufficient evidence for failure messages and dependency availability.

Adaptability10 / 18 · 2.8/5

Evidence shows: README describes multiple use cases (diverse data generation, relationship control, quality validation) and provides quick-start examples, indicating good audience and scenario coverage. Capability boundaries: docs mention async engine and model configuration but lack explicit limits. Trigger precision: CLI commands and skill installation provide triggers but not detailed conditions. Environment fit: supports Python 3.10-3.14 with installation instructions. Deductions: insufficient detail on trigger precision and capability boundaries.

Convention10 / 18 · 2.8/5

Evidence shows: README provides clear information architecture including quick start, docs links, and contribution guide. Install notes are detailed (pip and source). Naming stability: no major naming changes observed but no version history. Examples and FAQ: code examples and docs links provided, but no FAQ. Known limitations: README mentions async engine caveats but not comprehensive. License: Apache-2.0, complete. Versioning/changelog: no CHANGELOG file found. Maintenance responsibility: contribution guide and issue tracker provided. Deductions: missing FAQ, known limitations, and changelog.

Effectiveness7 / 13 · 2.7/5

Evidence shows: Output usability: README describes generated datasets suitable for production-grade synthetic data, with preview mode. Marginal value: multiple generation methods (statistical sampling, LLM, seed data) but no comparison with alternatives. Cost-benefit: no performance or cost data provided. Deductions: insufficient evidence for cost-benefit and marginal value.

Verifiability3 / 8 · 1.9/5

Evidence shows: Claims in README (e.g., '20T+ Tokens Processed') lack specific data sources but provide doc links. Cross-source corroboration: no independent verification found. Fact-inference separation: README distinguishes feature descriptions and telemetry data but does not explicitly separate facts and inferences. Deductions: claims lack traceability and no independent verification.

Risks and how to mitigate them
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • Publisher identity is unverified; treat source with caution.
  • Telemetry is enabled by default; be aware of privacy implications, disable with NEMO_TELEMETRY_ENABLED=false.
  • Dependency security comments indicate known vulnerabilities in some dependencies, but no full lockfile is provided; consider using uv.lock for reproducibility.
  • Performance claims in README (e.g., 20T+ tokens) lack verifiable data sources.
Evidence confidence: Low Reviewed Aug 11, 2026 Reviewed revision 4b18f5645e5c New commits since this review; the score may not cover them
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.9.5 v0.9.5 2026-10-13
    Release notes excerpt
    What's Changed * docs: link and cite the technical report by @dhruvnathawani in https://github.com/NVIDIA-NeMo/DataDesigner/pull/978 * chore: Drop transitive dep security floors from pyproject tomls by @mikeknep in https://github.com/NVIDIA-NeMo/DataDesigner/pull/987 * fix: forward tool_choice and merge per-call extra_body by @3mei in https://github.com/NVIDIA-NeMo/DataDesigner/pull/991 * fix: Classify httpx NetworkError and RemoteProtocolError as API_CONNECTION error kind by @mikeknep in https://github.com/NVIDIA-NeMo/DataDesigner/pull/1004 …
    View on GitHub ↗
  2. v0.9.4 v0.9.4 2026-10-05
    Release notes excerpt
    What's Changed * docs: add plans/README.md documenting the plan-document convention (#753) by @chethanuk in https://github.com/NVIDIA-NeMo/DataDesigner/pull/918 * fix: render degenerate judge histograms instead of raising (#905) by @chethanuk in https://github.com/NVIDIA-NeMo/DataDesigner/pull/919 * docs: fix conflicting lazy heavy import guidance in STYLEGUIDE.md (#759) by @chethanuk in https://github.com/NVIDIA-NeMo/DataDesigner/pull/920 * fix(engine): bound request fair queue selection state by @andreatnvidia in https://github.com/NVIDIA-NeMo/DataDesigner/pull/954 …
    View on GitHub ↗
  3. v0.9.3 v0.9.3 2026-09-21
    Release notes excerpt
    What's Changed * ci: bump NVIDIA-NeMo/FW-CI-templates/.github/workflows/_semantic_pull_request.yml from 1.8.10 to 1.9.1 in the all-actions group by @dependabot[bot] in https://github.com/NVIDIA-NeMo/DataDesigner/pull/917 * docs(agentic-ci): fix stale exception name in HuggingFaceHubClient docstrings by @github-actions[bot] in https://github.com/NVIDIA-NeMo/DataDesigner/pull/924 * fix: replace retired Nano Build model by @andreatnvidia in https://github.com/NVIDIA-NeMo/DataDesigner/pull/927 …
    View on GitHub ↗

FAQ

Does using NeMo Data Designer cost money?
The framework itself is open-source (Apache 2.0), but generating data requires API keys, which may incur costs depending on the provider. If using NVIDIA Build, it is intended for evaluation and testing only, not production.
Can I train on my own company data?
Yes, you can use your own seed data, but note that the process may involve calling third-party APIs, so ensure your data complies with the provider's terms of service and privacy policy.
Will the generated synthetic data contain personally identifiable information?
The framework offers person sampling that can generate demographic attributes, but you should be cautious with such data and ensure compliance with relevant regulations.
How do I ensure data quality?
Use built-in validators (Python, SQL, remote) to validate generated data, and use LLM-as-a-judge for scoring.
What if I encounter performance issues?
If you are experiencing high latency on self-hosted endpoints, adjust inference_parameters.timeout to match your actual per-request latency.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents