Tao Mine Nearest Neighbors

NVIDIAOfficialCreated by NVIDIA Corporation

Skill
Workflow
Data and AI
Apache-2.0
Medium risk
Has scripts

From the author

Run TAO Data Services TMM nearest-neighbor mining from embedding parquet files. Use when a workflow needs to mine source samples closest to target samples.

— the description by NVIDIA Corporation

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides an interface to execute the TAO Data Services TMM nearest-neighbor mining task. It processes source and target embedding parquet files to identify and retrieve the closest samples based on specified metrics. The skill includes utilities for generating and verifying experiment configuration files, ensuring that input paths and parameters are correctly formatted for the containerized execution environment.

What it does

Generates experiment configuration files for nearest-neighbor mining.
Validates configuration specs before execution.
Executes the TMM nearest-neighbor mining task using Docker.
Supports configurable distance metrics including cosine, euclidean, and manhattan.
Allows optional filtering of neighbors by label.
Produces a mined parquet file and a summary report of the mining process.

When to use it

When you need to identify source samples that are closest to specific target samples.
When working with embedding data stored in parquet format.
When you need to perform similarity searches within a dataset using TAO Data Services.
When you need to filter neighbor search results based on labels or distance thresholds.

Advantages

Automates the creation and validation of experiment specifications.
Provides a structured approach to managing input and output paths for containerized tasks.
Includes built-in verification steps to ensure environment and configuration readiness.
Offers flexible configuration for distance metrics and neighbor retrieval counts.

Usage examples

“Generate a nearest-neighbor mining spec for my source and target embeddings.”: The agent will run the preparation script to create a YAML configuration file with your specified source, target, and output paths.
“Run the nearest-neighbor mining task using my existing spec file.”: The agent will validate the spec and execute the TAO Data Services container to perform the mining and generate the results.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/tao-mine-nearest-neighbors/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip tao-mine-nearest-neighbors.zip -d .agents/skills

Documentation by NVIDIA Corporation

TAO Mine Nearest Neighbors

Use this skill to run TAO Data Services TMM nearest-neighbor mining. The skill consumes embedding parquets and writes a mined source-sample parquet plus a mining summary. It does not compute embeddings; upstream steps must produce the source and target embedding parquets first.

The container entrypoint is:

tmm nearest_neighbors -e /absolute/path/to/nearest_neighbors.yaml

TAO Data Services requires -e/--experiment_spec_file. The tmm console script converts that YAML into Hydra --config-path and --config-name arguments internally.

Inputs

The user can provide either an existing nearest-neighbors YAML spec or the fields needed to generate one.

Required spec fields:

Field	Meaning
`source_parquet`	Absolute path to the candidate/source embeddings parquet.
`target_parquet`	Absolute path to the target/query embeddings parquet.
`output_parquet`	Absolute path where TAO Data Services should write mined source filepaths.

Common optional fields:

Field	Default	Meaning
`topn`	`5`	Number of nearest source samples to retrieve per target sample.
`knn_metric`	`cosine`	One of `cosine`, `euclidean`, or `manhattan`.
`source_embed_column_name`	`embedding`	Embedding column in `source_parquet`.
`target_embed_column_name`	`embedding`	Embedding column in `target_parquet`.
`filter_by_label`	`"false"`	String flag. When `"true"`, TAO DS filters neighbors by matching `label` columns when both parquets provide labels.
`distance_threshold`	`-1.0`	Maximum distance to keep. Negative disables thresholding.

Both input parquets must contain a filepath column and a list-like embedding column. If filter_by_label is "true", both parquets should also contain label.

The default template is assets/default_nearest_neighbors.yaml.

Quick Start

Run from the tao-skill-bank repo root. Resolve the pinned TAO Data Services image from versions.yaml, verify the spec, mount the run root with identical host/container paths, and stream the Docker logs.

SPEC=/absolute/path/to/nearest_neighbors.yaml
RUN_ROOT=/absolute/path/that/contains/specs/data/and/results
GPU_COUNT=1

python3 skills/data/tao-mine-nearest-neighbors/scripts/verify_nearest_neighbors_spec.py \
  --spec "$SPEC"

DS_IMAGE="$(scripts/resolve_versions_key.py images.tao_toolkit.data_services)"

docker run --rm --gpus "$GPU_COUNT" --shm-size=8g --network=host \
  -v "$RUN_ROOT:$RUN_ROOT" \
  -w "$RUN_ROOT" \
  "$DS_IMAGE" \
  tmm nearest_neighbors -e "$SPEC"

Use at least one GPU. Choose GPU_COUNT from the hardware available to the host or platform that will run the container. If the user does not know the right value, inspect the host with nvidia-smi -L or ask which GPU allocation the run should use.

Do not pass --user $(id -u):$(id -g) to the TAO data-services container unless you have verified the image supports that UID. Some TAO DS images import Python packages that call getpass.getuser() at startup and fail when the UID is not present in /etc/passwd.

Generate A Spec

If the user provides source/target/output parquet paths instead of a ready spec, generate a spec from the default template:

python3 skills/data/tao-mine-nearest-neighbors/scripts/prepare_nearest_neighbors_spec.py \
  --source-parquet /absolute/path/source_embeddings.parquet \
  --target-parquet /absolute/path/target_embeddings.parquet \
  --output-parquet /absolute/path/results/mined.parquet \
  --output-spec /absolute/path/specs/nearest_neighbors.yaml \
  --topn 5 \
  --knn-metric cosine \
  --filter-by-label false \
  --distance-threshold -1.0

The generated YAML uses absolute paths. Keep the spec, input parquets, and output directory under RUN_ROOT so the same paths resolve inside the container.

Preflight

Before launching Docker:

Verify Docker and GPU access:

docker info > /dev/null
nvidia-smi -L

Resolve and pull the data-services image if needed:

DS_IMAGE="$(scripts/resolve_versions_key.py images.tao_toolkit.data_services)"
docker image inspect "$DS_IMAGE" > /dev/null || docker pull "$DS_IMAGE"

Validate the spec:

python3 skills/data/tao-mine-nearest-neighbors/scripts/verify_nearest_neighbors_spec.py \
  --spec "$SPEC"

Confirm RUN_ROOT contains the spec, both input parquets, and the output directory. Mount RUN_ROOT to the same absolute path inside Docker.

Outputs

The skill promises the artifacts named by the spec:

Artifact	Location
mined parquet	`output_parquet`
mining summary	`mining_summary.txt` next to `output_parquet`

The current TAO Data Services nearest_neighbors task writes a mined parquet with unique source filepath rows. The summary file reports mining counts such as queries processed, neighbors considered, duplicates removed, and any label/distance filtering.

Troubleshooting

The subtask nearest_neighbors requires -e/--experiment_spec_file: rerun with tmm nearest_neighbors -e "$SPEC". Hydra overrides alone are not enough.

Input parquet not found inside Docker: the YAML path must be visible inside the container. Use a RUN_ROOT mount where the host and container paths are identical.

Output directory is not writable after Docker exits: the TAO DS container may have written files as root. Inform the user, report which artifacts were produced, and ask whether to repair permissions on the output directory before continuing.

No GPU or cuDF/cuML errors: nearest-neighbor mining requires at least one CUDA GPU. Check nvidia-smi -L, the Docker --gpus flag, and the NVIDIA container toolkit installation.

Files

ATTRIBUTION.mdAdded by AutoGineer948 B
BENCHMARK.md7.0 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md6.1 KiB
assets/default_nearest_neighbors.yaml212 B
config/skillspector-baseline.yaml1.7 KiB
evals/evals.json902 B
references/skill_info.yaml561 B
scripts/prepare_nearest_neighbors_spec.pyScript8.0 KiB
scripts/verify_nearest_neighbors_spec.pyScript1.3 KiB
skill-card.md4.4 KiB
skill.oms.sig5.7 KiB

BENCHMARK.md

Skill Benchmark: tao-mine-nearest-neighbors

✅ Overall verdict: PASS — Recommended for publication

Publication Recommendation

Recommended for publication based on the completed evaluation evidence in this report.

Evaluation Metadata

Skill: tao-mine-nearest-neighbors
Evaluation date: 2026-10-16
Evaluator version: 1.5.6
Agents: Claude Code (aws/anthropic/bedrock-claude-opus-4-8), Codex (openai/openai/gpt-5.5)
Tasks: 1 evaluation tasks (1 positive)
Dataset digest: sha256:acb0bab13a495ae61fed1d8f7d142b32f3d6496e3d1dc838d105cf8bcaad70dd (skill-evaluator-dataset-snapshot/1)
Attempts per task: 1
Environment: k8s-sandbox
Tier 2 evidence: required for publication
Tier 3 evidence: required for publication

Each task attempt ran in its own isolated sandbox pod.

What This Report Answers

The three-tier evaluation checks whether the skill:

is safe to use;
produces correct answers;
is discovered and activated when needed;
helps the agent complete the user's goal and expected workflow; and
avoids wasted skill and tool usage.

Results at a Glance

Measure	Claude Code (Baseline → Skill Uplift)	Codex (Baseline → Skill Uplift)
Overall	94.6% — baseline ran, but no comparable score was available; uplift unavailable	64.7% — baseline ran, but no comparable score was available; uplift unavailable
Security	100.0% → 100.0% (±0.0 points)	100.0% → 100.0% (±0.0 points)
Correctness	0.0% → 100.0% (+100.0 points)	20.0% → 80.0% (+60.0 points)
Discoverability	100.0% — baseline ran, but no comparable score was available; uplift unavailable	0.0% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness	12.5% → 100.0% (+87.5 points)	40.0% → 45.0% (+5.0 points)
Efficiency	73.1% — baseline ran, but no comparable score was available; uplift unavailable	99.7% → 98.6% (-1.1 points)

How to read this table: baseline is the same task attempted without the target skill. Scores are rounded to one decimal; threshold-adjacent values use additional precision so their displayed band matches the verdict. Uplift is derived from those displayed scores and shown in percentage points.

Example: 47.0% → 92.0% (+45.0 points) means the skill-assisted run scored 92.0%, 45.0 percentage points above its 47.0% no-skill baseline.

A partial dimension was calculated from only the available configured signals; review the detailed report before relying on it.

Token Usage

Actual Tier 3 execution usage is reported for every observed agent/case pair and both conditions.

Agent	Dataset case	With skill	Without skill	Delta	Change	Coverage
claude-code	All cases	95,096	31,185	+63,911	+204.94%	skill 1/1; base 1/1
claude-code	tao-mine-nearest-neighbors-basic	95,096	31,185	+63,911	+204.94%	skill 1/1; base 1/1
codex	All cases	13,711	13,503	+208	+1.54%	skill 1/1; base 1/1
codex	tao-mine-nearest-neighbors-basic	13,711	13,503	+208	+1.54%	skill 1/1; base 1/1
ALL AGENTS	Dataset aggregate	108,807	44,688	+64,119	+143.48%	skill 2/2; base 2/2

Prompt tokens include cached reads, so total tokens are prompt + completion (cached is not added twice). The Efficiency score uses (prompt - cached) + completion. N/A means the relevant trajectory counters were not available; coverage is never estimated.

Tier Status

Tier	Purpose	Status	Evidence
Tier 1	Static validation	PASSED WITH OBSERVATIONS	11 validator(s); 19 finding(s)
Tier 2	Semantic deduplication	PASSED	2 validator(s); 0 finding(s)
Tier 3	Live agent evaluation	PASS	2 agent(s); 1 task(s)

Findings and Observations

<details> <summary>Show detailed findings and successful checks</summary>

MEDIUM QUALITY/quality_correctness: No documented scripts in table format (skills/data/tao-mine-nearest-neighbors/SKILL.md)
MEDIUM QUALITY/quality_correctness: Instructions don't mention 'run_script' (skills/data/tao-mine-nearest-neighbors/SKILL.md)
MEDIUM QUALITY/quality_correctness: SKILL_SPEC recommended field missing: 'metadata.tags' (skills/data/tao-mine-nearest-neighbors/SKILL.md)
MEDIUM SCHEMA/frontmatter_field_placement: Root field 'tags' is ignored; use 'metadata.tags' (skills/data/tao-mine-nearest-neighbors/SKILL.md)
MEDIUM SCHEMA/folder_hierarchy: Unexpected nesting depth for general skill (skills/data/tao-mine-nearest-neighbors)
14 additional finding(s) are available in the full evaluation artifacts.

</details>

Scoring Methodology

<details> <summary>Show dimension definitions, source signals, and thresholds</summary>

Dimension	Question	Scored signals
Security	Is it safe to use?	`security` (100%)
Correctness	Is the answer correct?	`accuracy` (100%)
Discoverability	Was the right skill loaded when needed?	`skill_execution` (100%)
Effectiveness	Did the skill help complete the task?	`goal_accuracy` (50%) + `behavior_check` (50%)
Efficiency	Did it avoid wasted tool calls and token usage?	`skill_efficiency` (50%) + `token_efficiency` (50%)

Dimension bands: PASS at 50% or above; NEUTRAL from 40% to below 50%; FAIL below 40%.
Overall Tier 3 lift: PASS at +5 points or more; FAIL at -10 points or less; values between those bands are NEUTRAL.
Overall verdict: PASS only when every configured dimension passes for at least one supported agent. Lift is reported as diagnostic evidence and does not override this gate.
The 50% attempt pass threshold is a separate per-task gate; it is not the dimension pass threshold.
Effectiveness is the equal-weight mean of goal completion (goal_accuracy) and expected workflow adherence (behavior_check).
Efficiency is 50% tool-call productivity (the backward-compatible skill_efficiency wire id) and 50% token_efficiency. Positive-case skill routing is scored under Discoverability, not Efficiency; a negative case without a routing target is N/A. N/A sources are omitted, remaining weights are renormalized, and the dimension is marked partial.

Signals present in this run:

security (Security): unsafe operations, secret leakage, and unauthorized access.
skill_execution (Skill Execution): whether the expected skill was selected, decoys were avoided, and the workflow executed.
skill_efficiency (Tool Productivity): tool-call productivity (legacy wire id; routing is scored under Discoverability).
accuracy (Accuracy): final-answer correctness against the reference answer.
goal_accuracy (Goal Accuracy): whether the user's goal was achieved.
behavior_check (Behavior Check): whether the expected workflow behavior was followed.
token_efficiency (Token Efficiency): actual uncached prompt plus completion usage (50% of Efficiency).

</details>

Freshness

Regenerate this benchmark when the skill, evaluation dataset, target agent/model, evaluator version, environment, or scoring policy changes.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Declares allowed tools, Needs a command-line tool, Needs Python

The author says: Requires docker, nvidia-container-toolkit, one or more CUDA GPUs, and the TAO data-services container pinned in versions.yaml.

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs
References to credential files
Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

NVIDIA Corporation

Publisher

NVIDIA (Official)

Source

NVIDIA/skills · skills/tao-mine-nearest-neighbors · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by NVIDIA Corporation or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download tao-mine-nearest-neighbors.zip