OPUS-5.5-DATABASE

A complete, open, decontaminated training corpus for language models — pretraining text, supervised fine-tuning conversations, preference pairs and a verifiable evaluation set — plus the full Python library that builds it and the scripts that train on it.

Total size	3.06B tokens across 5 configs
pretrain	2,125,527 documents · 2.60B tokens (English educational web, Turkish web, math web)
sft	592,337 conversations · 383.7M tokens (chat, instruction following, math, code, verified synthetic EN/TR)
preference	68,105 chosen/rejected pairs · 44.0M tokens (for DPO / ORPO / KTO / reward models)
tools	49,643 tool-use conversations · 68,742 tool calls · 30.0M tokens (calculator, Python, dates, units + 1000s of real-world APIs)
synth_eval	2,000 held-out items with programmatically verified answers (EN + TR)
Languages	English (primary), Turkish (second), plus 30+ languages from OpenAssistant
Removed	5,764 benchmark-contaminated rows · 409,969 duplicates
Licenses	only permissive sources: Apache-2.0, MIT, CC-BY-4.0, ODC-By (per-row license column)

Name & affiliation. "OPUS-5.5" is simply the name of this project. The dataset is not affiliated with, endorsed by, or produced by Anthropic, and it contains no outputs of Anthropic's Claude models. The OPUS-synth generators (Python code in code/opusdb/synth.py) were written with AI coding assistance; the examples themselves are produced deterministically by that code, not sampled from a language model.

Quick start

from datasets import load_dataset

sft  = load_dataset("KeremTT/OPUS-5.5-DATABASE", "sft", split="train")          # chat SFT (messages format)
pref = load_dataset("KeremTT/OPUS-5.5-DATABASE", "preference", split="train")   # DPO pairs
pre  = load_dataset("KeremTT/OPUS-5.5-DATABASE", "pretrain", split="train", streaming=True)  # raw text
tools = load_dataset("KeremTT/OPUS-5.5-DATABASE", "tools", split="train")       # function calling / agents
ev   = load_dataset("KeremTT/OPUS-5.5-DATABASE", "synth_eval", split="test")    # verifiable eval

# filter by capability / language / license with the metadata columns
math_tr = sft.filter(lambda r: r["domain"].endswith("math") or r["language"] == "tr")

Train with the included scripts (TRL):

pip install "trl>=0.20" "transformers>=4.45" peft datasets accelerate
huggingface-cli download KeremTT/OPUS-5.5-DATABASE --repo-type dataset --include "code/*" --local-dir opus55
cd opus55/code
accelerate launch train/sft_trl.py --model Qwen/Qwen2.5-1.5B --epochs 2              # full SFT
accelerate launch train/sft_trl.py --model meta-llama/Llama-3.1-8B --lora --epochs 2 # LoRA SFT
accelerate launch train/dpo_trl.py --model ./opus55-sft --beta 0.1                   # preference tuning
python train/eval_synth.py --model ./opus55-dpo --limit 500                          # verifiable eval

What a good training set needs — and how this one is built

A strong model is not trained on "a lot of text"; it is trained in stages, and each stage needs data with a different shape. OPUS-5.5-DATABASE ships one config per stage and applies the same quality controls to all of them.

stage	what the model learns	what the data must look like	config
1. Pretraining	language, world knowledge, reasoning patterns	huge, diverse, clean, deduplicated plain text; high share of educational content, math and multilingual text	pretrain
2. Supervised fine-tuning	following instructions, conversation format, step-by-step answers	high-quality prompt → response conversations covering many skills, correct answers, multi-turn	sft
2b. Tool use / agents	when to call a tool, how to format the call, how to use the result, how to recover from errors	multi-turn conversations with tool definitions, calls, real tool outputs and final answers	tools
3. Preference optimisation	which of two answers is better (helpfulness, correctness)	pairs of chosen vs. rejected responses with a real quality gap	preference
4. Evaluation	—	held-out, decontaminated, automatically checkable	synth_eval

The build pipeline (code/scripts/build.py) enforces the properties that research has repeatedly shown to matter:

1. Quality over quantity — educational web text (FineWeb-Edu classifier score ≥ 3), Gopher-style document rules (length, symbol ratio, word length, repeated lines, bullet/ellipsis lines), reward-model/quality labels kept only at "good"/"excellent" for synthetic chat, and an argilla-style quality recipe for preference pairs.
2. Deduplication — exact dedup on normalised text for every config, plus MinHash-LSH near-duplicate removal (word 5-gram shingles, 128 permutations, 16 bands) on SFT prompts across all sources.
3. Benchmark decontamination — every pretraining document, SFT prompt and preference prompt is checked for 13-gram overlap (plus whole-phrase matches for 10-12-word items in chat data) against GSM8K-test, MATH-500, HumanEval and MMLU-test. 5,764 rows were removed.
4. Correctness you can trust — the opus-synth subset is generated by code that also computes the answer; every arithmetic line in every response is re-evaluated, and every code answer is executed against unit tests before it is accepted.
5. Capability balance — general chat, instruction-following with constraints, rewriting, summarisation, human-written multilingual dialogue, math, code, logic, dates, string manipulation, structured JSON output and knowing when a question cannot be answered.
6. Multilinguality — Turkish is a first-class language: Turkish web text for pretraining, ~35% of opus-synth is in Turkish (with correct vowel-harmony suffixes and Turkish alphabetical order), plus OpenAssistant dialogues in 30+ languages.
7. Safety & privacy — e-mail addresses and IP addresses are replaced with <EMAIL> / <IP_ADDRESS>; responses that claim to be ChatGPT/OpenAI or contain "as an AI language model" boilerplate are removed.
8. Licensing & provenance — only permissively licensed sources; each row carries source and license.
9. Reproducibility — the complete library, source registry (with exact upstream files), seeds and statistics are in the code/ folder of this repository.

Composition

sft — 592,337 conversations, 383.7M tokens

source	upstream	license	rows	tokens
smol-magpie-ultra	HuggingFaceTB/smoltalk	apache-2.0	136,898	213.9M
openmathinstruct2	nvidia/OpenMathInstruct-2	cc-by-4.0	99,654	49.2M
magicoder-oss	ise-uiuc/Magicoder-OSS-Instruct-75K	mit	74,782	42.1M
metamathqa	meta-math/MetaMathQA	mit	93,999	23.6M
smol-summarize	HuggingFaceTB/smoltalk	apache-2.0	39,869	19.9M
opus-synth	original (this repo)	apache-2.0	59,730	10.5M
smol-rewrite	HuggingFaceTB/smoltalk	apache-2.0	29,908	9.67M
oasst2	OpenAssistant/oasst2	apache-2.0	13,444	7.52M
smol-constraints	HuggingFaceTB/smoltalk	apache-2.0	23,961	5.48M
codealpaca	sahil2801/CodeAlpaca-20k	cc-by-4.0	19,892	1.80M
gsm8k	openai/gsm8k	mit	200	36.9K

preference — 68,105 pairs, 44.0M tokens

source	upstream	license	rows	tokens
ultrafeedback	HuggingFaceH4/ultrafeedback_binarized	mit	52,595	38.1M
orca-dpo	argilla/distilabel-intel-orca-dpo-pairs	apache-2.0	5,650	3.46M
opus-synth-pref	original (this repo)	apache-2.0	9,860	2.39M

opus-synth-pref pairs a verified step-by-step solution (chosen) with the same solution in which one intermediate result was corrupted and the error propagated to a wrong final answer (rejected) — this teaches the model to prefer correct reasoning, not just a nicer style.

tools — 49,643 conversations, 68,742 tool calls, 30.0M tokens

source	upstream	license	rows	tokens
opus-synth-tools	original (this repo)	apache-2.0	30,000	19.0M
toolace	Team-ACE/ToolACE	apache-2.0	10,675	6.94M
glaive-fc-v2	glaiveai/glaive-function-calling-v2	apache-2.0	7,868	2.86M
hermes-fc	NousResearch/hermes-function-calling-v1	apache-2.0	1,100	1.21M

The tools config teaches a model to act as an agent: read the tool definitions, decide whether a tool is needed, emit a correctly formatted call, read the result and answer — or explain an error.

OPUS-synth-tools (original, verified) ships with a real tool runtime, code/opusdb/agent_tools.py, so the same tools the model was trained on can be executed at inference time:

tool	what it does
calculator	exact arithmetic (fractions, powers, sqrt, log, trig, factorial, gcd)
python	runs a short Python program and returns stdout or the error
date_calc	days between dates, adding days, weekday
unit_convert	length, mass, volume, time, temperature

Behaviours covered (calc_single: 5,902, python_compute: 5,429, dates: 4,429, calc_chain: 4,351, parallel: 3,606, python_repair: 2,933, tool_error: 1,808, out_of_scope: 838, no_tool: 704): single calls, chained calls (the output of one call feeds the next), parallel calls in one turn, writing and running code, repairing code after an error, explaining tool errors, answering directly when no tool is needed, and declining when no available tool can do the job. Every tool output in the data is the real output of the runtime, and every final answer is computed from it. Hermes-FC, ToolACE (thousands of distinct real-world API schemas) and Glaive-FC-v2 add breadth.

Rows store tool_calls and tools as JSON strings so heterogeneous argument types fit in Parquet. Decode them for any chat template that supports tools (Qwen 2.5/3, Llama 3.1+, Mistral, Hermes, ...):

import sys; sys.path.insert(0, "opus55/code")
from opusdb.tool_formats import to_chat_template
messages, tools = to_chat_template(row)
text = tokenizer.apply_chat_template(messages, tools=tools, tokenize=False)

Agent loop at inference time:

from opusdb.agent_tools import TOOL_SPECS, call_tool, parse_tool_calls
conv = [{"role": "user", "content": "How many primes are below 100000?"}]
while True:
    out = generate(tokenizer.apply_chat_template(conv, tools=TOOL_SPECS, add_generation_prompt=True, tokenize=False))
    calls = parse_tool_calls(out)
    if not calls:
        print(out); break
    conv.append({"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": c} for c in calls]})
    conv += [{"role": "tool", "name": c["name"], "content": str(call_tool(c["name"], c["arguments"]))} for c in calls]

The reference python tool runs code in a separate interpreter with a timeout; it is not a security sandbox. Run it inside a container without network access or credentials when serving untrusted users.

pretrain — 2,125,527 documents · 2.60B tokens (English educational web, Turkish web, math web)

source	upstream	license	documents	tokens
fineweb-edu	HuggingFaceFW/fineweb-edu	odc-by	1,438,202	1.51B
fineweb2-tr	HuggingFaceFW/fineweb-2	odc-by	600,000	909.5M
open-web-math	open-web-math/open-web-math	odc-by	87,325	186.2M

synth_eval — 2,000 verifiable items

Families: word_problem (620), algebra (203), logic (169), strings (157), json (156), dates (152), arithmetic (135), number_theory (111), code (108), unanswerable (95), units (94). Prompts are generated with a separate seed and are guaranteed not to appear in sft or preference.

Data fields

sft: id, messages (list of {role, content}, roles system/user/assistant), source, domain, language, license, num_turns, num_tokens.

preference: id, prompt, chosen (messages), rejected (messages), source, domain, language, license, score_chosen, score_rejected, num_tokens.

pretrain: id, text, source, domain, language, license, url, num_tokens.

tools: id, messages (list of {role, content, tool_calls, tool_call_id, name}; tool_calls is a JSON string), tools (JSON string, OpenAI function schema), source, domain, language, license, num_tool_calls, num_tokens.

synth_eval: id, family, language, difficulty (1-3), prompt, answer (ground truth; for code items the unit tests), reference_response.

Token counts use the HuggingFaceTB/SmolLM2-135M tokenizer (49k BPE). Other tokenizers will differ by roughly ±15% for English and more for Turkish.

How it performs at different model sizes

There are three kinds of numbers below, and they are labelled clearly:

• MEASURED — experiments actually run on this data; the scripts that produced them are in code/train/.
• PROJECTION — computed from published scaling laws (Hoffmann et al. 2022 "Chinchilla"; Muennighoff et al. 2023 for repeated data). They show trends, not guarantees.
• ESTIMATE — arithmetic on token counts (6·N·D FLOPs), e.g. GPU-hours.

MEASURED: off-the-shelf models on synth_eval and the effect of OPUS-SFT

model	params	overall	English	Turkish	notes
SmolLM2-135M-Instruct	0.135B	1.7%	0.0%	3.7%	off-the-shelf
SmolLM2-135M-Instruct + OPUS-SFT	0.135B	28.3%	30.3%	25.9%	+ OPUS-SFT, 4,000 examples, 1 epoch on opus-synth rows, CPU, lr 1e-4
SmolLM2-360M-Instruct	0.36B	10.0%	9.1%	11.1%	off-the-shelf
Qwen2.5-0.5B-Instruct	0.5B	28.3%	39.4%	14.8%	off-the-shelf
Qwen2.5-1.5B-Instruct	1.5B	30.0%	45.5%	11.1%	off-the-shelf

All rows use the same 60 randomly sampled synth_eval items, greedy decoding, the model's own chat template, and the exact-match scorer in code/train/eval_synth.py. With n = 60 the 95% interval is roughly ±10-12 points, so read differences of a few points as noise.

Caveat: synth_eval comes from the same generators as the opus-synth training rows (different seed, no shared prompts), so the fine-tuned row measures how well a model learns these procedures and answer formats — e.g. JSON extraction and recognising unanswerable questions go to 100% — not general intelligence. Off-the-shelf rows show how hard the set is for models that never saw it; note how much weaker they are on the Turkish items.

MEASURED: small-scale pretraining ladder on pretrain

GPT-style decoder models of increasing size trained from scratch on the same sample of the pretrain config (same token stream, same hyper-parameters, the same token budget for every model, CPU only), evaluated on the same held-out tokens:

model	layers × width	params	training tokens	tokens/param	CPU time	final val loss
xs	2 × 64	640.8K	6.00M	9.4	4 min	5.823
s	3 × 128	1.68M	6.00M	3.6	6 min	5.556
m	4 × 192	3.40M	6.00M	1.8	9 min	5.484
l	6 × 256	6.90M	6.00M	0.9	15 min	5.490

Reading the result. With the same 6.00M-token budget, validation loss falls from 5.82 (640.8K params) to 5.48 (3.40M params) and then stops improving at 6.90M params (5.49). That plateau is the data-limited regime: at ~1 token per parameter a larger model cannot use its extra capacity. This is exactly why the projections below scale data with model size (≈20 tokens per parameter) — and why 4B-27B models should start from a pretrained base rather than from the pretrain config alone. These are tiny CPU runs (minutes each), so absolute losses are high; the trend, not the level, is the point.

PROJECTION & ESTIMATE: 0.1B – 70B

model size	Chinchilla-optimal tokens (20/param)	epochs over OPUS pretrain	projected loss, unlimited data	projected loss, OPUS pretrain only
0.135B	2.7B	1.0	3.328	3.328
0.5B	10B	3.8	2.789	2.801
1B	20B	7.7	2.580	2.608
4B	80B	30.7	2.275	2.363
8B	160B	61.5	2.164	2.300
14B	280B	107.6	2.090	2.268
27B	540B	207.5	2.018	2.239
70B	1400B	537.8	1.937	2.207

How to read this. The pretrain config alone (2.60B unique tokens) is compute-optimal only for small models (≈ unique tokens ÷ 20 parameters, i.e. on the order of 100M parameters). Beyond that a model needs more data than the config contains; repeating it up to ~4 epochs is almost as good as fresh data (Muennighoff et al. 2023), but larger models should use pretrain as a high-quality mid-training / annealing mix next to a larger web corpus, not as the only source. The sft and preference configs, in contrast, are useful at every size — post-training needs quality and coverage, not trillions of tokens.

Recommended recipe by model size

model size	how to use OPUS-5.5-DATABASE	suggested settings
≤ 150M (from scratch)	pretrain on pretrain (≈1-2 epochs), then full SFT on sft, then DPO	lr 3e-3 → 3e-4 pretrain; SFT lr 1e-4, 3 epochs
0.3B – 1B	mix pretrain into the last 10-20% of pretraining (annealing), full SFT 2-3 epochs, DPO 1 epoch	SFT lr 5e-5 – 1e-4, DPO β = 0.1, lr 5e-7
1B – 8B	full SFT or LoRA (r = 64, all linear layers) 2 epochs, then DPO 1 epoch	SFT lr 2e-5 (full) / 2e-4 (LoRA), max length 4096
13B – 70B	LoRA / QLoRA SFT 1-2 epochs, DPO with LoRA	LoRA r = 16-64, lr 1e-4, β = 0.05-0.1

Recommended recipe: fine-tuning a 4B model with tool use

The projection table above is about pretraining from scratch. If you fine-tune an existing 4B model, you do not need 80B tokens — you need the right post-training stages:

stage	data	settings (4B)	why
0. (optional) Turkish continued pretraining	pretrain where language == "tr" (≈0.9B tokens) mixed ~50/50 with English	lr 1e-5 – 2e-5, 1 epoch	only if the base model is weak in Turkish
1. SFT	sft + tools (tools upsampled ×2)	full FT: lr 2e-5, 2 epochs, max length 4096, assistant-only loss; LoRA: r 64, lr 2e-4	instruction following, step-by-step answers, tool calling
2. Preference (DPO)	preference	lr 5e-7 (full) / 5e-6 (LoRA), β 0.1, 1 epoch	prefers correct and helpful answers
3. Evaluate	synth_eval, tools test	eval_synth.py, eval_tools.py --format hermes	before/after comparison

Estimated cost for stage 1: ~15 H100-hours (full fine-tune, 2 epochs, 40% MFU) or roughly a third of that with LoRA; a single 80 GB GPU is enough for full fine-tuning of 4B with gradient checkpointing, a 24 GB GPU with LoRA. Everything is wired up in one script: code/train/recipe_4b.sh (BASE=<your model> bash train/recipe_4b.sh).

sft_trl.py --with-tools renders tool conversations in a template-independent Hermes format (tool schemas in the system prompt, <tool_call> / <tool_response> blocks), so it works for Qwen, Llama, Gemma, Mistral or Phi bases alike. After training, plug the model into the bundled tool library:

import sys; sys.path.insert(0, "opus55/code")
from opusdb.agent import Agent
agent = Agent.from_pretrained("./opus55-4b-dpo")
agent.register({"type": "function", "function": {"name": "get_stock", "description": "Units in stock for a SKU",
                "parameters": {"type": "object", "properties": {"sku": {"type": "string"}}, "required": ["sku"]}}},
               lambda sku: {"sku": sku, "units": 42})          # your own tools work the same way
print(agent.run("What is 17.5% of 2,384,190? Then how many days until 2027-01-01 from 2026-11-10?", verbose=True))

What to expect from a 4B, 8B, 14B or 27B model trained on it

At these sizes OPUS-5.5-DATABASE is a post-training dataset: start from an existing open base model (e.g. a 4B/8B/14B/27B base checkpoint from the Qwen, Llama, Gemma or Mistral families) and run sft + tools → preference. Pretraining a 4B+ model from scratch needs ~80B-540B tokens (20 tokens/parameter), far more than the pretrain config; the base model's own pretraining determines most of its knowledge. The table below is a qualitative expectation based on the data composition and on published results of similarly-sized models after comparable post-training — not a measured benchmark of this dataset.

capability	4B	8B	14B	27B
Multi-turn chat, instruction following, format constraints	good	good	very good	very good
Grade-school math word problems, step by step (GSM8K-style)	mostly correct	reliable	reliable	reliable
Competition math (MATH-style)	basic	partial	solid	strong
Python functions / small scripts	simple functions	everyday tasks	most tasks	strong
Tool calling: right tool, valid JSON arguments	good on known tools	reliable	reliable, parallel calls	reliable, multi-step plans
Multi-step agent loops, error recovery	short chains	2-4 steps	longer chains	longest chains
Turkish	understands, simpler answers	fluent everyday Turkish	fluent	fluent, nuanced
Structured JSON output	good	reliable	reliable	reliable
Saying "I can't" / "not enough information"	learned	learned	learned	learned
World knowledge, up-to-date facts	limited to base model	limited to base model	limited to base model	limited to base model

What the data specifically adds: an exact step-by-step answer style (every line checkable), calling a calculator or Python instead of guessing arithmetic, recovering from tool errors, structured outputs, refusing out-of-scope tool requests, and Turkish coverage. What it cannot add: new world knowledge beyond the base model, long-context skills (> 8k tokens), vision, or frontier-level reasoning. Use synth_eval and code/train/eval_tools.py to measure your model before and after training.

Filter by domain or language to specialise (e.g. a Turkish math tutor: language == "tr" plus all math sources).

The library (code/)

code/
├── opusdb/
│   ├── sources.py     # registry: upstream repo, exact files, verified license, caps
│   ├── synth.py       # OPUS-synth: 11 families of verified EN/TR generators + preference corruption
│   ├── synth_tools.py # OPUS-synth-tools: 9 verified tool-use behaviours (EN/TR)
│   ├── agent_tools.py # tool runtime: calculator, python, date_calc, unit_convert + call parser
│   ├── tool_formats.py# Hermes / ToolACE / Glaive converters, chat-template helpers
│   ├── agent.py       # Agent loop: run a fine-tuned model with the tools (and your own)
│   ├── text.py        # normalisation, hashing, PII scrubbing, language id, Gopher quality rules
│   ├── dedup.py       # exact + MinHash-LSH near-duplicate detection (numpy)
│   └── decontam.py    # 13-gram benchmark decontamination (rolling hashes, numpy)
├── scripts/
│   ├── download.py    # fetch upstream files
│   ├── build.py       # full pipeline -> Parquet configs + statistics
│   ├── charts.py      # all figures in this card
│   └── make_card.py   # this README, generated from the statistics
└── train/
    ├── recipe_4b.sh       # end-to-end 4B recipe: SFT(+tools) -> DPO -> eval
    ├── sft_trl.py         # SFT with TRL (full or LoRA), --with-tools adds the tools config
    ├── dpo_trl.py         # DPO with TRL
    ├── eval_synth.py      # exact-match evaluation on synth_eval
    ├── eval_tools.py      # agent-loop evaluation on the tools test split
    ├── small_sft.py       # dependency-light SFT loop used for the measured experiment
    └── scaling_ladder.py  # from-scratch scaling ladder used for the measured experiment

Rebuild everything:

pip install datasets huggingface_hub pyarrow numpy tokenizers matplotlib
python scripts/download.py            # ~11 GB of upstream files
python scripts/build.py               # writes out/data/** and out/stats/**
python scripts/charts.py && python scripts/make_card.py

Generate more verified synthetic data:

from opusdb import synth
for ex in synth.generate(10, seed=123, tr_ratio=0.5):
    print(ex["prompt"], "\n->", ex["answer"])

Limitations

• Synthetic chat sources (SmolTalk Magpie-Ultra, MetaMathQA, OpenMathInstruct-2, Magicoder, UltraFeedback) were produced by other open or proprietary models and inherit their biases and occasional errors; only opus-synth is verified by construction.
• opus-synth is template-based: it teaches procedures and format robustly but has less linguistic variety than human writing. Use it as a 5-15% ingredient, not alone.
• Language identification for English/Turkish uses a lightweight heuristic; other covers all remaining languages.
• Decontamination covers GSM8K, MATH-500, HumanEval and MMLU only. Check your own benchmarks before reporting results.
• Web text can contain offensive or incorrect content despite filtering.
• The scaling projections use constants fitted on other corpora and tokenizers; treat them as order-of-magnitude guides.

Licensing and attribution

Each row keeps the license of its upstream source in the license column; when you redistribute a subset, keep the attribution required by that license (CC-BY-4.0 and ODC-By require attribution). Original material in this repository (opus-synth, opus-synth-pref, synth_eval, and all code) is released under Apache-2.0. FineWeb-Edu, FineWeb-2 and OpenWebMath are made available under ODC-By 1.0 and are also subject to the Common Crawl terms of use.

Upstream datasets: HuggingFaceFW/fineweb-edu, HuggingFaceFW/fineweb-2, open-web-math/open-web-math, HuggingFaceTB/smoltalk, OpenAssistant/oasst2, meta-math/MetaMathQA, nvidia/OpenMathInstruct-2, openai/gsm8k, ise-uiuc/Magicoder-OSS-Instruct-75K, sahil2801/CodeAlpaca-20k, HuggingFaceH4/ultrafeedback_binarized, argilla/distilabel-intel-orca-dpo-pairs. Thank you to all their authors.

Citation

@misc{opus55database2026,
  title  = {OPUS-5.5-DATABASE: an open, decontaminated, multi-stage training corpus with verified synthetic data},
  author = {KeremTT},
  year   = {2026},
  url    = {https://huggingface.co/datasets/KeremTT/OPUS-5.5-DATABASE}
}