adaption-ai — Claude Code skill: what it does, how to install
Guides your agent in augmenting datasets and creating synthetic training data with the Adaption AI Python SDK.
MIT 1 installs ★ 12 updated 2026-10-29
npx skills add svngoku/coding-agents-skills --skill adaption-ai -a claude-codeWhat adaption-ai does
This skill provides instructions for building dataset workflows using the Adaption Python package. It walks through uploading local files (.csv, .json, .parquet), importing data from Hugging Face or Kaggle, polling execution, and downloading outputs via presigned S3 URLs.
Workflows rely on client.datasets.run(). Every run requires dataset_id and a column_mapping containing a prompt key. The skill shows how to configure recipe parameters like DPO preference pairs, reasoning traces, and search-grounded hallucination mitigation.
External imports from Hugging Face and Kaggle happen asynchronously. Starting a run before row_count appears processes an empty file. Working with the platform requires an ADAPTION_API_KEY and the adaption package.
What it helps with
- generate DPO preference pairs for fine-tuning
- add chain-of-thought reasoning traces to dataset completions
- reduce hallucinations using search-grounding controls
- import datasets from Hugging Face or Kaggle into an augmentation run
Example prompts for the agent
- Write a Python script using Adaption SDK to upload
train.parquetand create DPO preference pairs. - Set up an augmentation run with reasoning traces and cost estimation on my dataset.
- Poll the Adaption API for job completion, check quality evaluation scores, and download the output.
How to install adaption-ai
1Skills CLI (Vercel)
npx skills add svngoku/coding-agents-skills --skill adaption-ai -a claude-code2Manually: put the files in place
~/.claude/skills/adaption-ai/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/adaption-ai/
1Skills CLI (Vercel)
npx skills add svngoku/coding-agents-skills --skill adaption-ai -a codex2Manually: put the files in place
.agents/skills/adaption-ai/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add svngoku/coding-agents-skills --skill adaption-ai -a cursor2Manually: put the files in place
.cursor/skills/adaption-ai/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install svngoku/coding-agents-skills skills/adaption-ai2Manually: put the files in place
.github/skills/adaption-ai/SKILL.md1Skills CLI (Vercel)
npx skills add svngoku/coding-agents-skills --skill adaption-ai -a gemini-cli2Platform CLI
gemini skills install https://github.com/svngoku/coding-agents-skills --path skills/adaption-aiManually: put the files in place
.devin/skills/adaption-ai/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add svngoku/coding-agents-skills --skill adaption-ai -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about adaption-ai
How to install adaption-ai in Claude Code?
Run npx skills add svngoku/coding-agents-skills --skill adaption-ai -a claude-code. You can also place the file at ~/.claude/skills/adaption-ai/SKILL.md.
What does the adaption-ai skill do?
It teaches the agent how to build synthetic data pipelines, configure brand controls, and fetch metrics with the Adaption Python client.
What parameters are required to run an adaptation job?
Calling client.datasets.run() requires a dataset_id and a column_mapping dictionary containing at least the prompt key.
Source text
SKILL.md · MIT
---
name: adaption-ai
description: Adaption AI SDK for synthetic data augmentation and dataset adaptation. Use when building data pipelines with the Adaption Python SDK, uploading datasets (local files, Hugging Face, Kaggle), running augmentation/adaptation jobs, configuring brand controls (hallucination mitigation, safety categories, length), recipe specifications (reasoning traces, deduplication, preference pairs, prompt rephrase), evaluating dataset quality, downloading results, or any workflow involving `pip install adaption`, `from adaption import Adaption`, Adaptive Data, or the adaptionlabs.ai API. Also trigger when the user mentions synthetic data generation for fine-tuning, dataset augmentation pipelines, DPO preference pair generation, or grounding-based hallucination reduction on training data.
---
# Adaption AI SDK Skill
Build dataset augmentation pipelines with [Adaption's Adaptive Data](https://docs.adaptionlabs.ai/) platform. This skill covers the full lifecycle: ingest → adapt → wait → evaluate → export.
## Quick Reference
```bash
pip install adaption
```
```python
from adaption import Adaption
client = Adaption(api_key="pt_live_...") # or set ADAPTION_API_KEY env var
```
**Async client**: `from adaption import AsyncAdaption`
## Core Lifecycle
1. **Ingest** — Upload local file, import from HuggingFace, or import from Kaggle
2. **Adapt** — Start an augmentation run with column mapping + optional controls
3. **Wait** — Poll for completion with exponential backoff
4. **Evaluate** — Fetch quality metrics (score_before/after, improvement %)
5. **Export** — Download augmented dataset via presigned URL
## Ingest Methods
### Local file upload
Supported formats: `.csv`, `.json`, `.jsonl`, `.parquet`
```python
result = client.datasets.upload_file("training_data.csv")
result = client.datasets.upload_file("data.csv", name="my-dataset") # custom name
dataset_id = result.dataset_id
```
### Hugging Face import (async on server — poll before running)
```python
resp = client.datasets.create_from_huggingface(
url="https://huggingface.co/datasets/org/repo",
files=["train.csv"],
)
```
### Kaggle import (requires Kaggle API creds registered in Adaption settings)
```python
resp = client.datasets.create_from_kaggle(
url="https://www.kaggle.com/datasets/org/dataset-name",
files=["data.csv"],
)
```
## Running Adaptation Jobs
### `datasets.run()` — the central method
**Required**: `dataset_id`, `column_mapping` with at least `"prompt"` key.
```python
run = client.datasets.run(
dataset_id,
column_mapping={
"prompt": "instruction", # required
"completion": "response", # optional
# "chat": "conversation", # optional — alternative to prompt+completion
# "context": ["source", "ref"],# optional — list of context columns
},
# --- Optional controls (see references/ for details) ---
brand_controls={...},
recipe_specification={...},
job_specification={...},
estimate=True, # dry-run: get cost quote without starting
)
```
**Response fields**: `run.run_id`, `run.estimated_credits_consumed`, `run.estimated_minutes`
### Brand Controls (`brand_controls`)
| Key | Type | Purpose |
|-----|------|---------|
| `hallucination_mitigation` | `bool` | Web-search grounding to reduce fabricated content |
| `length` | `"minimal"│"concise"│"detailed"│"extensive"` | Target verbosity |
| `safety_categories` | `list[str]` | Content categories to enforce (e.g. `["harassment","hate"]`) |
### Recipe Specification (`recipe_specification`)
```python
recipe_specification={
"recipes": {
"reasoning_traces": True, # chain-of-thought in completions
"deduplication": True, # remove near-duplicates
"preference_pairs": True, # DPO chosen/rejected pairs
"prompt_rephrase": True, # rephrase prompts for variety
"prompt_metadata_injection": True, # inject context into prompts
},
"version": "...", # optional schema version
}
```
### Job Specification (`job_specification`)
```python
job_specification={
"max_rows": 500, # subsample for pilots
"idempotency_key": "...", # safe retries
}
```
## Wait, Evaluate, Export
```python
from adaption import DatasetTimeout
# Wait (exponential backoff 2s→30s, default timeout 1hr)
try:
status = client.datasets.wait_for_completion(dataset_id, timeout=600)
except DatasetTimeout as e:
print(f"Still running after {e.timeout}s")
# Evaluate quality
ev = client.datasets.get_evaluation(dataset_id)
# ev.status: pending | running | succeeded | failed | skipped
# ev.quality.score_before, ev.quality.score_after, ev.quality.improvement_percent
# Download
url = client.datasets.download(dataset_id) # presigned S3 URL
```
## When to read more
| Need | Read |
|------|------|
| Full run parameters, all API endpoints, HTTP/curl examples | `references/api-reference.md` |
| Hallucination mitigation, safety, length, reasoning traces guides | `references/guides.md` |
| End-to-end scripts (upload→adapt→evaluate→download) | `scripts/e2e_pipeline.py` |
| Async patterns | `scripts/async_pipeline.py` |
## Key Patterns
- **Always estimate first** on large datasets: `estimate=True` before real run
- **Poll after HF/Kaggle import**: ingestion is async; wait for `row_count is not None`
- **Evaluation lags adaptation**: run may show `succeeded` before eval finishes — poll `get_evaluation` separately
- **Combine controls freely**: `brand_controls` + `recipe_specification` + `job_specification` all compose on one `datasets.run()` call
## Anti-Patterns to Avoid
- **Running a real job without estimating first** — on large datasets, always call with `estimate=True` and check `estimated_credits_consumed` before spending budget
- **Reading results right after HF/Kaggle import** — ingestion is async; wait until `row_count is not None` before running a job, or you'll process an empty dataset
- **Treating run completion as evaluation completion** — the run can show `succeeded` while the evaluation is still `running`; poll `get_evaluation` separately
- **Retrying without an `idempotency_key`** — naive retries on network errors create duplicate jobs; set `job_specification.idempotency_key`
- **Missing the `prompt` key in `column_mapping`** — it is required; jobs fail with confusing errors when the mapping is incomplete
## When to Use / Not Use
**Use this skill when:**
- Generating synthetic training data or augmenting existing datasets for fine-tuning
- Building DPO preference pairs, reasoning traces, or grounded (hallucination-mitigated) training data
- Working with the Adaption Python SDK (`pip install adaption`) or the adaptionlabs.ai API
**Do NOT use this skill when:**
- The data only needs simple cleaning/formatting — a local pipeline is cheaper
- The work must stay fully on-premises with no external platform dependency
- You are not using Adaption's platform — use the generic dataset pipelines of the framework you're already on
© svngoku · MIT · svngoku/coding-agents-skills