Datasets:

vfleaking
/

capysft

pretty_name: CapySFT
task_categories:
  - text-generation
size_categories:
  - 100K<n<1M
tags:
  - sft
  - reasoning
  - tool-use
  - synthetic
source_datasets:
  - allenai/tulu-3-sft-mixture
  - HuggingFaceTB/smoltalk
configs:
  - config_name: 500M
    data_files:
      - split: train
        path: data/train-00000-of-00004.jsonl.gz
  - config_name: 1B
    default: true
    data_files:
      - split: train
        path:
          - data/train-00000-of-00004.jsonl.gz
          - data/train-00001-of-00004.jsonl.gz
  - config_name: 2B
    data_files:
      - split: train
        path: data/train-*.jsonl.gz

CapySFT

CapySFT is a dataset for supervised fine tuning of assistants that can reason, answer questions, and use terminal tools. User requests come from Tulu 3 and SmolTalk. New assistant responses were generated with DeepSeek-V4-Flash-0731.

Dataset sizes

Choose 500M, 1B, or 2B supervised response tokens. Token counts use our LLM course's truncated Qwen3.5 tokenizer (32,768 base tokens plus 33 special tokens), included under tokenizer/. Counts vary with the tokenizer and chat formatting.

Configuration	Source conversations	Training records	Supervised response tokens	Files
`500M`	199,455	217,998	500,024,135	first 1
`1B` (default)	399,746	436,342	1,000,019,252	first 2
`2B`	785,488	862,479	1,999,896,726	all 4

The configurations share four compressed JSONL files, each with approximately 500 million supervised response tokens. Smaller configurations are subsets of the larger ones. Related records from the same source conversation stay in one file. Each configuration contains only a train split.

One record is a complete training segment. Long source conversations can produce several records when their history is summarized and generation continues. Retained segments are not truncated and fit within 16,384 tokens. Supervised counts include selected assistant reasoning, answers, tool calls, summaries, and the end marker of each selected message. Context messages and tool results do not contribute to these counts.

Load with Hugging Face

Use the standard datasets interface:

from datasets import load_dataset

data = load_dataset("vfleaking/capysft", "1B", split="train", token=True)
example = data[0]
print(example["messages"])
print(example["supervised_message_indices"])

Change "1B" to "500M" or "2B" to choose a size. Add streaming=True to iterate without building a complete local Arrow cache. While the repository is private, log in with an account that has access.

Record format

The three fields needed for training are:

Field	Type	Meaning
`messages`	list of message dictionaries	All messages in conversation order, including those used only as context.
`tools`	JSON string or null	Available tool definitions. Decode with `json.loads` before applying a chat template.
`supervised_message_indices`	list of integers	Indices into `messages` identifying assistant messages to supervise.

Messages have role and content, and may have reasoning_content, tool_calls, or tool_call_id. Each tool call has id, type, and function. Its function.arguments field is a JSON string. Missing optional message fields load as None. Remove only those null fields, preserving empty strings and lists:

import copy
import json

messages = [
    {key: value for key, value in message.items() if value is not None}
    for message in copy.deepcopy(example["messages"])
]
for message in messages:
    for call in message.get("tool_calls", []):
        call["function"]["arguments"] = json.loads(call["function"]["arguments"])
tools = json.loads(example["tools"]) if example["tools"] is not None else None

Each row also has id, a unique record identifier, and conversation_id, shared by records from the same source conversation. Group by conversation_id when making a validation split to keep related records together.

The metadata dictionary retains source, generation, segmentation, and token statistics:

Metadata field	Meaning
`source`	Prompt mixture: `tulu3` or `smoltalk`.
`subset`	Original subset label within the mixture.
`original_global_index`	Source conversation's index in the prepared prompt collection.
`original_conversation_id`	Original generation identifier, retained for tracing a record to its source.
`generation_status`	Recorded generation outcome. Completed segments are retained even when later generation did not complete.
`segment_index`	Segment order within the source conversation.
`segment_type`	`initial`, `compaction` (summary generation), or `continuation` (generation after a summary).
`segment_end_reason`	Recorded reason this segment ended.
`generated_responses`	Number of newly generated assistant messages; equals the length of `supervised_message_indices`.
`response_tokens`	Number of supervised response tokens.
`full_tokens`	Number of input tokens, including context and the final message's end marker.

Other source metadata, when present, is also retained.

Tokenization and supervision

The supplied chat template preserves reasoning on every assistant turn. After preparing messages and tools as above, render and tokenize with:

from huggingface_hub import snapshot_download
from transformers import AutoTokenizer

snapshot = snapshot_download(
    "vfleaking/capysft", repo_type="dataset", allow_patterns="tokenizer/*", token=True
)
tokenizer = AutoTokenizer.from_pretrained(f"{snapshot}/tokenizer")
text = tokenizer.apply_chat_template(
    messages, tools=tools, tokenize=False, add_generation_prompt=False
)
text = text.removesuffix("\n")
tokens = tokenizer.encode(text, add_special_tokens=False)

Supervise only assistant messages selected by supervised_message_indices. For each selected message, include its opening <think>, reasoning, closing </think>, answer or complete tool call, and closing <|im_end|>. Include newlines within that body. Mask the assistant role header, the newline after its end marker, all other messages, and padding.

Earlier assistant messages can be context only. For example, a generated summary is supervised when first produced, then appears as masked history in a later record. Keep these earlier messages as input.

The final <|im_end|> ends the segment. Remove only the following template newline and do not append another end token. When packing records together, keep attention and target shifting within each record.

How the data was generated

We used a small agent harness developed for our LLM course assignments, which we call MiniCapyCode. It runs the conversation loop between the model and a sandboxed Linux environment. The model may use bash, read, edit, and write tools, receive their results, and continue its response. Tool use is optional.

Generation used thinking enabled, low reasoning effort, temperature=1, and top_p=1. Later user questions could be rewritten in conversation context. When a conversation approached the context limit, the harness could ask the model to summarize its history and continue from that summary. Summary requests and responses are included as separate training records.

The generated responses can contain errors. Some source conversations ended before all turns completed, but their completed training segments are retained. There is no validation or test split, and the data has not been checked for overlap with every benchmark.

Sources and terms

The source prompts come from Tulu 3 SFT Mixture and SmolTalk. Each record retains the source and subset labels in metadata.

Upstream terms differ by subset, and some Tulu 3 subsets restrict commercial use. Regenerating responses does not remove conditions on the source prompts. See LICENSE.md and the upstream dataset cards for licenses, attribution, and terms governing generated outputs. No single permissive license is asserted for the entire mixture.