Litdata logo

Litdata

Organization
Lightning-AI
litdata

Expert use of the LitData library and work on its codebase. Use when writing or reviewing code that calls litdata (StreamingDataset, StreamingDataLoader, StreamingRawDataset, optimize, map, CombinedStreamingDataset, ParallelStreamingDataset, TokensLoader, serializers, typed media wrappers Text/Audio/Video/Image/Jpeg/File/Tensor/Graph/…, list_media_folder, litdata_collate, train_test_split, complete_dataset, merge_datasets, index_parquet_dataset, index_hf_dataset), answering how-to questions, choosing raw vs optimize vs parquet/HF/MDS, keyed lookup (`key_fn`, `build_keys_index`, `dataset_update`, `get_by_key`), elastic mid-epoch resume, tuning cache/prefetch/shuffle/seed, resolving paths (s3/gs/r2/azure/hf/local:/teamspace via resolver.py), documenting or debugging optimize/map I/O (shared queue, async Downloader download/upload, LITDATA_OPTIMIZE_*), FsProvider vs Downloader, FUSE s3_connections/s3_folders, multi-node DATA_OPTIMIZER_* / num_nodes jobs, POSIX-fast mmap, litsim simulator, or when navigating/editing src/litdata, tests, CI, examples/modality, or debugging streaming / optimize / map. Also use for enable_tracer / Litracer / Perfetto, and multi-worker s3:// FileNotFoundError or obstore-after-fork / Studio R2 data_connection_id Session TypeError.

Overview

PublisherLightning-AI
RepositorylitData
Skill namelitdata
Stars
616
Forks
110
Bundled files
16
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 16 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by Lightning-AI on GitHub. Read the source before you install it.

Installation

Install the Litdata AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/Lightning-AI/litData/tree/main/.claude/skills/litdata
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/Lightning-AI/litData.git /tmp/litData
mkdir -p .claude/skills
cp -r /tmp/litData/.claude/skills/litdata .claude/skills/litdata
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Litdata in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Litdata on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Litdata is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

LitData

LitData (import litdata) preprocesses and streams datasets for PyTorch training:

  • Write (optimize / map) → chunked chunk-*.bin + index.json → src/litdata/processing/
  • Read (StreamingDataset + StreamingDataLoader) → cache → decode → batch → src/litdata/streaming/
  • Raw (StreamingRawDataset) → stream original files without optimize → src/litdata/raw/

To use the library expertly: always load reference/using-litdata.md first. Narrative source: repo README.md.

Install this skill

From any project (Cursor, Claude Code, and other agents supported by the skills CLI):

bash
npx skills add Lightning-AI/litData

Useful options: -g (user-global), -a cursor (Cursor only), -y (non-interactive). In this repo the skill already lives at .claude/skills/litdata/.

Expert usage (load using-litdata.md)

Before writing examples or answering how-tos, read the cookbook. Highlights:

TopicRemember
Raw filesStreamingRawDataset + torch DataLoader — #stream-raw / §10. Prefer cloud URL / connection path over FUSE. Defaults: max_concurrent_downloads=None (adaptive Stage 1), max_prefetch=16 (worker-aware ~64 aggregate), hedge_delay=0, download_timeout=120 (batch-level), range_parallel_threshold=0. Explicit int concurrency = exact permits.
Images / mediaAlways wrap so a caption is not a path: Text / Image / Audio / Video / File / … (types.py). Class folders: list_media_folder(root, kind=…). Recipes: examples/modality/. README #modality (#media-types). Bare PIL.Image / fromarray → huge PIL RAW. litdata_collate only special-cases graphs — Audio/Video need a custom collate_fn.
Train streamOptimized: StreamingDataLoader + shuffle=True, drop_last=True, seed=…
Optimizeif __name__ == "__main__"; exactly one of chunk_bytes | chunk_size. Default 64MB; multi‑MB samples → consider 256–512MB. Shuffle the sample list before optimize() when source order matters — README #faq-chunk-shuffle
Ordered dataChunk/item shuffle ≠ file-level shuffle. Shuffle before optimize, or use StreamingRawDataset + DataLoader(shuffle=True). LitData does distributed + within-chunk bucket sampling automatically
CachePeak disk ≈ num_workers × max_pre_download × chunk_size; default max_cache_size=None (75% of free disk, leave ≥50GB). "100G" or 0.90 of free.
POSIX-fastLocal/Vast/NFS: mmap in place, no cache copy. WindowShuffle only on parallel FS (or LITDATA_POSIX_FAST=1). Cap workers / skip WILLNEED from MemAvailable. LITDATA_POSIX_FAST=0 disables.
PathsStudio /teamspace/s3_connections & co are FUSE (convenience only — slow, can crash under load). LitData resolves them and talks directly to S3/GCS/R2. Never read the mount by hand. reference/resolver.md + reference/data-movement.md
Optimize I/ODefault keep_data_ordered=False: per-node shared queue; download/upload/remove are node-level threads. Remote I/O uses the streaming Downloader (adownload_file / aupload_file). FsProvider is the fallback / index path. Tune LITDATA_OPTIMIZE_* / LITDATA_PREFETCH_BYTES. Load reference/data-movement.md.
Multi-nodenum_nodes= = Lightning Studio job (_execute), not torchrun/SLURM. Shard by DATA_OPTIMIZER_*; all ranks upload chunks; last node merges {node}-index.json → index.json. Load reference/multi-node.md.
ThroughputRough ImageNet Studio order-of-magnitude (not guarantees): FUSE ~600/s · Raw (right tuning) ~6–7k/s · Optimized 64MB chunks ~11k/s — using-litdata.md FAQ. Raw benches: medians + provenance SHAs; never cite short-window n=1 against Stage 0 medians.
Tracingfrom litdata.debugger import enable_tracer then enable_tracer(level="chunk") (or categories=["download","read","delete"]). Convert with Lightning-AI/litracer: litracer --quiet --validate -o trace.json.gz litdata_debug.log. One line per event; crashes go to stderr + ph: I. Full spec: reference/debugging.md.
S3 workersindex.json is boto3 (no parent tokio). Workers lazy-init obstore; boto3 fallback if parent already started it. Do not pass data_connection_id / endpoint_url into boto3.Session — build obstore from S3Client/R2Client. FileNotFoundError after 120s with num_workers>0 only → debugging.md failure modes.
Keyed lookupoptimize(..., key_fn=...) writes keys/. Read ds["id"] / get_by_key. Patch locally with dataset_update. Needs polars. keyed-lookup.md.
Parquet / HFOne-liner: StreamingDataset("hf://datasets/org/name/data") (auto-index + ParquetLoader). Index persists at {cache}/hf-index/<hash>/index.json (no re-scan). Default prefetches whole parquet then local to_pylist(). Do not default range_read=True (lost to HF on Hub). spawn with workers. Token: HF_TOKEN. using-litdata.md §10.

Reference map

TaskRead
Use the library (raw, optimize/stream, modality, parquet/HF, serializers)reference/using-litdata.md
Paths / URLs / Studio mounts / Dir / time templatesreference/resolver.md (+ README #resolve-paths)
Downloaders / uploaders / removers / FUSE→cloud / optimize I/Oreference/data-movement.md (+ processing.md)
Multi-node optimize/map (num_nodes, DATA_OPTIMIZER_*, index merge)reference/multi-node.md (+ processing.md)
Read path, shuffle math, item loaders, Combined/Parallelreference/streaming.md
Cache / BinaryWriter / BinaryReader / index.json / FsProvider / samplerreference/storage-format.md
Cache / prefetch / eviction / shared-chunk deletionreference/cache-and-chunk-lifecycle.md
Env vars (async prefetch, cache, debug, DATA_OPTIMIZER_*, Studio)reference/env-vars.md
Fair streaming benchmarks (benchmarks/ suite)reference/benchmarking.md
Offline streaming what-if (litsim)repo simulator/README.md
Raw adaptive concurrency / look-ahead stages (clients own rate)repo benchmarks/ADAPTIVE_CONCURRENCY.md
Lightning Studio env, credentials, free-threadingreference/lightning-studio.md
Write path orchestration; raw internals; pointers to I/O + multi-nodereference/processing.md
Dev env, PR/CI stylereference/contributing.md
Tests & fixturesreference/testing.md
Tracing (enable_tracer, Litracer, Perfetto), breakpoints, env knobsreference/debugging.md
Keyed lookup / dataset_update / key_fnreference/keyed-lookup.md

Public API (src/litdata/__init__.py)

SymbolPurpose
StreamingDataset / StreamingDataLoaderOptimized stream + resumable loader
CombinedStreamingDataset / ParallelStreamingDatasetMix or zip streams
StreamingRawDatasetRaw file stream
TokensLoaderToken windows for LLMs
optimize / map / merge_datasets / walk / complete_datasetWrite / transform / merge / finish index
list_media_folder / iter_webdataset_tarClass-folder / WebDataset ingest lists
Audio Video Image Jpeg JpegArray Pil Tiff File Mesh Pdf Nifti Tensor Text GraphTyped media leaves for optimize
litdata_collateLoader default; PyG Batch only for graphs
dataset_update / build_keys_indexKeyed in-place patch / backfill sidecar
train_test_splitSplit by chunk ROIs
index_parquet_dataset / index_hf_dataset / optimize_hfIndex parquet / convert Hub parquet → chunks
breakpointMultiprocessing-safe pdb
enable_tracer (litdata.debugger)Pipeline log → Litracer / Perfetto

Defined under streaming/, processing/, raw/, utilities/ — see cookbook §6–9 for constructor args.

Package map

  • streaming/ — read · processing/ — write · raw/ — raw stream · types.py — media wrappers · cli/ — litdata cache path|clear
  • utilities/ — env, encryption, subsample, split, parquet, HF
  • constants.py — optional-dep flags, env knobs, default chunk 64 MB
  • Registries: downloaders, fs providers, serializers, compressors; resolver.py → Dir

Shared concepts

  • Chunk: [num_items][offsets][data]; index.json holds chunks + config (data_format, item_loader, …) — storage-format.md.
  • Item loaders own layout + intervals (PyTreeLoader, TokensLoader, ParquetLoader).
  • Training downloads = Downloader. Optimize remote I/O prefers the same Downloader (adownload_file / aupload_file); FsProvider remains for index merge and fallback. See data-movement.md. Sampler ChunkedIndex is read-path; CacheBatchSampler is CacheDataLoader only.
  • Ranks from env (_DistributedEnv / DATA_OPTIMIZER_*), not a custom network.
  • Shuffle deterministic from seed+epoch+chunk → resumable (shuffle.py, not sampler.py). Local POSIX-fast keeps FullShuffle unless the mount is Vast/NFS/Lustre/GPFS (or LITDATA_POSIX_FAST=1 → WindowShuffle).
  • Design: one less thing to remember; pure PyTorch; backward compatible; test-driven.

Traps (do not “fix” by guessing)

  • FileNotFoundError / ChunkWaitTimeoutError after ~120s on chunks with num_workers>0 is usually prefetch-thread death or wait timeout — not a missing object. Check stderr + tracer crash.
  • mode="append" vs use_checkpoint=True: append continues chunk indices; checkpoint resumes input slices. Combining them is unsafe; checkpoint filenames / done_till_index are known-fragile (writer.save_checkpoint vs data_processor load).
  • Azure/HF resolve for read; optimize write providers are s3/gs/r2 only (_SUPPORTED_PROVIDERS).
  • dataset_update: local dirs only; ds[int] is positional.
  • Empty Tensor() is not tokens. Only 1-D Tensor(array=…) (or path= / bytes= + dtype=) uses the TokensLoader layout. Empty Text() / JpegArray() fail on write.
  • Bare .txt / .npy / .bin path strings pickle the path. Wrap with Text / File / load the array. Bare *.jpg / *.png / *.wav paths are claimed as media.
  • litdata_collate only batches graphs. A dict with AudioDecoder / video decoder + a stackable field needs a custom collate_fn (see examples/modality/audio.py).

Quick commands

bash
make setup
pre-commit run --all-files
mypy
pytest tests/path/test_x.py::test_name -v --capture=no
litdata cache path
litdata cache clear

Examples: examples/ (modality recipes: examples/modality/). Version: src/litdata/__about__.py.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Litdata AI skill do?

Expert use of the LitData library and work on its codebase. Use when writing or reviewing code that calls litdata (StreamingDataset, StreamingDataLoader, StreamingRawDataset, optimize, map, CombinedStreamingDataset, ParallelStreamingDataset, TokensLoader, serializers, typed media wrappers Text/Audio/Video/Image/Jpeg/File/Tensor/Graph/…, list_media_folder, litdata_collate, train_test_split, complete_dataset, merge_datasets, index_parquet_dataset, index_hf_dataset), answering how-to questions, choosing raw vs optimize vs parquet/HF/MDS, keyed lookup (`key_fn`, `build_keys_index`, `dataset_upd...

Why use Litdata on TypingMind?

Because you install it once and use it with any model. Litdata is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Litdata in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/Lightning-AI/litData/tree/main/.claude/skills/litdata. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Litdata?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Litdata?

As many as you like. As long as a model supports skills, you can use Litdata with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Litdata AI skill free?

Yes. It is published on GitHub by Lightning-AI under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇