MTEB-lite

MTEB-lite is a set of small subsets of embedding benchmarks that estimate a text-embedding model's full-benchmark scores at a small fraction of the cost:

• eng: MTEB(eng, v2) (41 tasks), K = 100 items per task
• eng-super: MTEB(eng, v2) (41 tasks), K = 20 items per task
• ara-super: Arabic MMTEB (42 test tasks), K = 20 items per task

For every task, a fixed set of items (queries, test examples, sentence pairs, clustering items, documents, bitext pairs) was chosen from a candidate pool. The subset's statistic, after a per-task linear calibration, tracks the full-task main score across a diverse set of reference models.

This repository contains only item ids, selection weights, item-model parameters and calibration coefficients, plus code. No text from any dataset is redistributed. mteb_lite.py rebuilds the selected items from the original datasets through mteb (dataset revisions pinned by mteb 1.39.7) and evaluates a model with mteb's own per-task prompts.

Configs

config	benchmark	tasks	K (items / task)	selection	items	texts to encode	tokens	encode time, 0.6B model*
eng	MTEB(eng, v2)	41	100	v2	3936	64455	12.38M	~6.9 min
eng-super	MTEB(eng, v2)	41	20	v3	820	33263	5.33M	~3.0 min
ara-super	Arabic MMTEB (42 test tasks)	42	20	v4	840	40601	3.96M	~2.2 min

* Qwen3-Embedding-0.6B at about 30k tokens/s on one GPU, the rate we measured in our full MTEB runs. Tokens are counted with the Qwen3 tokenizer, including instruction prefixes; Arabic texts are capped at 512 tokens, as in our Arabic MMTEB eval. English selection versions: eng uses selection v2 (28 reference models) and eng-super uses selection v3 (46 reference models, including 18 additional public English models). On the 15 new public models with all 41 full scores, the fixed v2 K=100 selection is out-of-sample and matched the v3 re-selection on macro tau (0.924 both) with a lower MAE (0.34 vs 0.59), so eng keeps v2. For K=20, v3 was clearly better (macro tau 0.905 vs 0.790, equal MAE 0.99), so eng-super uses v3.

Layout: <config>/manifest.json holds the task list, main scores, dataset paths / revisions, K, estimators, calibration and reference models. <config>/<Task>.json holds the selected ids plus whatever scoring needs, and <config>/calibration.csv the per-task calibration. mteb_lite.py is the loader + evaluator, validation/<config>.{md,json} the validation reports, SELECTION.md the selection method, models.csv the reference models, and code/ the scripts used to build pools, score models, select and evaluate.

Usage

pip install "mteb==1.39.7" sentence-transformers numpy scikit-learn
python mteb_lite.py --model sentence-transformers/all-MiniLM-L6-v2 --config eng-super --out result.json

from mteb_lite import evaluate, load_task
res = evaluate("BAAI/bge-small-en-v1.5", config="eng")      # an mteb model name, or any mteb Encoder object
res["estimated_macro"], res["estimated_mean"]              # estimated benchmark macro (mean over task types) / mean (x100)
res["rows"]["ArguAna"]                                     # subset statistic + calibrated full-task estimate
task = load_task("eng", "STS12")                           # the selected items with their texts

The model is called exactly as mteb calls it: model.encode(texts, task_name=..., prompt_type=query|document|None). Instruction models therefore get their own per-task instructions. Pass mteb.get_model(name) (or just the name) for models mteb knows; wrap other models in an mteb Encoder. For the Arabic configs, set the model's max sequence length to 512 to match the reference runs.

Calibration

For every task, full_estimate = a + b * subset_statistic. The subset statistic is one of:

• weighted_mean: the anchor-weighted mean of the per-item outcomes;
• pirt: the p-IRT estimate of the pool score (observed items + item-model predictions for the rest);
• gp: the average of the two;
• set_metric: Spearman / weighted AP / V-measure of the selected items (STS, pair classification, clustering).

a and b are least-squares fits over the config's reference models that have a full score for the task. The benchmark estimates are the macro (mean over task types of the mean over tasks) and the mean (over tasks) of the per-task estimates, x100. The coefficients are in every <config>/<Task>.json, in <config>/manifest.json, and in:

config	file	tasks	median fit r	min fit r	median residual SD (points)
eng	eng/calibration.csv	41	0.972	0.456	1.30
eng-super	eng-super/calibration.csv	41	0.907	-0.000	2.56
ara-super	ara-super/calibration.csv	42	0.972	0.042	1.86

The fit r and residual SD are in-sample (on the fitting models). Out-of-sample accuracy is in the validation tables below.

What each task file contains (ids only)

• Retrieval: the selected query ids, and per query its candidate document ids (BM25 top-30 over the full corpus + its relevant documents, at most 100) and its qrels; also the ids of the random corpus documents shared by all queries. A query is ranked against its own candidates + the shared random documents, and its nDCG@10 is the item outcome.
• Reranking: the selected samples (row indices). Each keeps its own candidate list from the dataset. The outcome is AP (nDCG@10 for MIRACL-style main scores).
• Classification: the selected test rows, the train rows that mteb's undersampling protocol draws (n_experiments x samples_per_label per label, seed 42) and the per-experiment row lists. The outcome is the fraction of the logistic-regression experiments that are correct.
• BitextMining: the selected gold pairs plus a fixed set of distractor target sentences per language pair. The outcome is 1 if the gold target is the nearest neighbour.
• STS / PairClassification / Clustering: the selected pair / item rows (+ pair label weights, clustering label depth), scored as sets.
• Summarization: the selected document ids; the outcome is the per-document Spearman.
• p-IRT tasks: additionally the ids, weights and item parameters of the whole candidate pool (no texts).

Id scheme. We use the source dataset's own ids where they exist (retrieval query / document ids, SummEval document ids). Otherwise an id is <prefix><row>, the row index in the evaluation split of the dataset exactly as mteb==1.39.7's task.load_data() returns it (after mteb's own dataset_transform). The prefix is r (reranking sample), t (test example), p (pair, flattened pair list), s (STS pair), c (clustering item) or b (bitext gold pair). Classification train rows are train-split row indices. Retrieval task files also store a 16-hex SHA-1 of every needed query / document text, and the loader matches texts by these hashes. This is needed because some mteb loaders (e.g. MintakaRetrieval, MKQARetrieval, PublicHealthQA, XPQARetrieval) number queries and documents via enumerate(set(...)), so their ids change from process to process. The hashes also act as an integrity check. In multi-subset tasks (the Arabic configs), ids are prefixed with <hf_subset>|, and bitext targets are <language or subset>|<row>. Each task file records the dataset path, revision, eval split and hf_subset(s).

Arabic configs. These are the 42 Arabic MMTEB test tasks (7 bitext mining, 14 classification, 2 clustering, 2 pair classification, 2 reranking, 11 retrieval, 4 STS). Each task is restricted to its Arabic hf_subsets (Arabic, Arabic dialects, and Arabic-English pairs) and to the split our Arabic MMTEB evaluation uses, and the task score is the mean over subsets. Texts are capped at 512 tokens. The MIRACLReranking pool was cut to 300 queries (encode cost). The full-task scores of the 8 multilingual public reference models (multilingual-e5 small / base / large, bge-m3, LaBSE, embeddinggemma-300m, paraphrase-multilingual MiniLM-L12 / mpnet-base) are our own complete runs of all 42 tasks with the same subsets and splits; the English-only public models enter only the tasks with official full scores. Only ara-super (K=20) is released: it beats uniform random K under family-level leave-one-model-out (macro tau 0.732 vs 0.711, mean tau 0.772 vs 0.764). The K=100 Arabic selection does not yet beat random K (macro tau 0.769 vs 0.778) and is withheld until it does.

Reference models

Selection and calibration use a diverse reference set: our model families, each thinned to at most 3 models (best / median / worst by full score), plus every public and base model. Every model that was scored is listed below and in models.csv, which also gives each model's role per config, internal id, family and merge recipe. Our merges are described only by their merge recipe.

model	internal id	type	suites scored	tasks with full scores	used in configs
ADIP-QCRI/ADIP-Embedding-v1-0.6B	F-lin0.5	ADIP release	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
ADIP-QCRI/ADIP-Embedding-v2-0.6B	V5-ties-d0.1-l0.5	ADIP release	eng	eng: 41	eng, eng-super
Qwen/Qwen3-Embedding-0.6B	qwen3-0.6b	Qwen base	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
Qwen/Qwen3-Embedding-0.6B + ADIP tokenizer	qwen3-0.6b+norm	Qwen base	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
Qwen/Qwen3-Embedding-4B	qwen3-4b	Qwen base	eng/ara	eng: 39, ara: 42	eng, eng-super, ara-super
BAAI/bge-base-en-v1.5	bge-base-en-v1.5	public	eng	eng: 41	eng-super
BAAI/bge-large-en-v1.5	bge-large-en-v1.5	public	eng	eng: 41	eng-super
BAAI/bge-m3	bge-m3	public	eng/ara	eng: 27, ara: 42	eng, eng-super, ara-super
BAAI/bge-small-en-v1.5	bge-small-en-v1.5	public	eng	eng: 41	eng-super
Snowflake/snowflake-arctic-embed-l	arctic-embed-l	public	eng	eng: 41	eng-super
Snowflake/snowflake-arctic-embed-m-v1.5	arctic-embed-m-v1.5	public	eng	eng: 41	eng-super
Snowflake/snowflake-arctic-embed-xs	arctic-embed-xs	public	eng	eng: 41	eng-super
WhereIsAI/UAE-Large-V1	UAE-Large-V1	public	eng	eng: 41	eng-super
avsolatorio/GIST-small-Embedding-v0	GIST-small-Embedding-v0	public	eng	eng: 41	eng-super
google/embeddinggemma-300m	embeddinggemma-300m	public	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
intfloat/e5-base-v2	e5-base-v2	public	eng/ara	eng: 41, ara: 21	eng, eng-super, ara-super
intfloat/e5-large-v2	e5-large-v2	public	eng	eng: 41	eng-super
intfloat/e5-small-v2	e5-small-v2	public	eng	eng: 41	eng-super
intfloat/multilingual-e5-base	multilingual-e5-base	public	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
intfloat/multilingual-e5-large	multilingual-e5-large	public	eng/ara	eng: 40, ara: 42	eng-super, ara-super
intfloat/multilingual-e5-small	multilingual-e5-small	public	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
mixedbread-ai/mxbai-embed-large-v1	mxbai-embed-large-v1	public	eng	eng: 41	eng-super
sentence-transformers/LaBSE	LaBSE	public	eng/ara	eng: 41, ara: 42	eng-super, ara-super
sentence-transformers/all-MiniLM-L12-v2	all-MiniLM-L12-v2	public	eng	eng: 38	eng-super
sentence-transformers/all-MiniLM-L6-v2	all-MiniLM-L6-v2	public	eng/ara	eng: 41, ara: 28	eng, eng-super, ara-super
sentence-transformers/all-mpnet-base-v2	all-mpnet-base-v2	public	eng	eng: 39	eng-super
sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2	paraphrase-multilingual-MiniLM-L12-v2	public	ara	ara: 42	ara-super
sentence-transformers/paraphrase-multilingual-mpnet-base-v2	paraphrase-multilingual-mpnet-base-v2	public	eng/ara	eng: 41, ara: 42	eng-super, ara-super
thenlper/gte-large	gte-large	public	eng	eng: 41	eng-super
thenlper/gte-small	gte-small	public	eng	eng: 41	eng-super
ADIP weighted soup: 0.7·ADIP-v3 (final) + 0.3·ADIP-v4, linear merge λ=0.7 into Qwen3-Embedding-0.6B	W-F0.7-V0.3-l0.7	ADIP merge	ara	ara: 42	ara-super
ADIP weighted soup: 0.7·ADIP-v3 (step 6750) + 0.3·ADIP-v2-ft, linear merge λ=0.5 into Qwen3-Embedding-0.6B	W-A0.7-V2-0.3-l0.5	ADIP merge	ara	ara: 42	ara-super
ADIP weighted soup: 0.7·ADIP-v3 (step 6750) + 0.3·ADIP-v3 stage-3, linear merge λ=0.5 into Qwen3-Embedding-0.6B	W-A0.7-S3-0.3-l0.5	ADIP merge	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
ADIP-v3 (final), TIES d=0.1 λ=0.5 into Qwen3-Embedding-0.6B	F-ties-d0.1-l0.5	ADIP merge	eng	eng: 41	eng, eng-super
ADIP-v3 (final), linear merge λ=0.4 into Qwen3-Embedding-0.6B	F-lin0.4	ADIP merge	eng/ara	eng: 41, ara: 42	ara-super
ADIP-v3 (final), linear merge λ=0.6 into Qwen3-Embedding-0.6B	F-lin0.6	ADIP merge	eng	eng: 41	not used
ADIP-v3 (final), linear merge λ=1.0 into Qwen3-Embedding-0.6B	F-lin1.0	ADIP merge	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
ADIP-v3 (pre-rehearsal), TIES d=0.1 λ=0.5 into Qwen3-Embedding-0.6B	P-ties-d0.1-l0.5	ADIP merge	eng	eng: 41	not used
ADIP-v3 (pre-rehearsal), linear merge λ=0.5 into Qwen3-Embedding-0.6B	P-lin0.5	ADIP merge	eng	eng: 41	not used
ADIP-v3 (step 6750) + ADIP-v2-ft, DARE-TIES p=0.9 λ=0.5 into Qwen3-Embedding-0.6B	AV2-dareties-p0.9-l0.5	ADIP merge	eng	eng: 33	not used
ADIP-v3 (step 6750) + ADIP-v2-ft, DARE-TIES p=0.9 λ=1.0 into Qwen3-Embedding-0.6B	AV2-dareties-p0.9-l1.0	ADIP merge	eng/ara	eng: 33, ara: 42	eng, eng-super, ara-super
ADIP-v3 (step 6750) + ADIP-v2-ft, TIES d=0.3 λ=0.5 into Qwen3-Embedding-0.6B	AV2-ties-d0.3-l0.5	ADIP merge	eng	eng: 33	not used
ADIP-v3 (step 6750) + ADIP-v2-ft, TIES d=0.3 λ=1.0 into Qwen3-Embedding-0.6B	AV2-ties-d0.3-l1.0	ADIP merge	eng	eng: 33	not used
ADIP-v3 (step 6750) + ADIP-v2-ft, linear merge λ=0.5 into Qwen3-Embedding-0.6B	AV2-lin0.5	ADIP merge	eng/ara	eng: 33, ara: 42	eng, eng-super, ara-super
ADIP-v3 (step 6750) + ADIP-v2-ft, linear merge λ=1.0 into Qwen3-Embedding-0.6B	AV2-lin1.0	ADIP merge	eng/ara	eng: 33, ara: 42	eng, eng-super, ara-super
ADIP-v3 (step 6750) + stage-3: ADIP-v3 (step 6750) + ADIP-v3 stage-3, DARE-TIES p=0.9 λ=1.0 into Qwen3-Embedding-0.6B	AS3-dareties-p0.9-l1.0	ADIP merge	eng/ara	eng: 33, ara: 42	eng, eng-super, ara-super
ADIP-v3 (step 6750) + stage-3: ADIP-v3 (step 6750) + ADIP-v3 stage-3, TIES d=0.3 λ=0.5 into Qwen3-Embedding-0.6B	AS3-ties-d0.3-l0.5	ADIP merge	eng/ara	eng: 33, ara: 42	eng, eng-super, ara-super
ADIP-v3 (step 6750) + stage-3: ADIP-v3 (step 6750) + ADIP-v3 stage-3, TIES d=0.3 λ=1.0 into Qwen3-Embedding-0.6B	AS3-ties-d0.3-l1.0	ADIP merge	eng/ara	eng: 33, ara: 42	eng, eng-super, ara-super
ADIP-v3 (step 6750) + stage-3: ADIP-v3 (step 6750) + ADIP-v3 stage-3, linear merge λ=1.0 into Qwen3-Embedding-0.6B	AS3-lin1.0	ADIP merge	eng	eng: 33	not used
ADIP-v3 (step 6750), DARE p=0.5 λ=0.5 into Qwen3-Embedding-0.6B	A-dare-p0.5-l0.5	ADIP merge	eng	eng: 41	not used
ADIP-v3 (step 6750), DARE p=0.9 λ=1.0 into Qwen3-Embedding-0.6B	A-dare-p0.9-l1.0	ADIP merge	ara	ara: 42	ara-super
ADIP-v3 (step 6750), TIES d=0.1 λ=0.5 into Qwen3-Embedding-0.6B	A-ties-d0.1-l0.5	ADIP merge	eng	eng: 41	eng, eng-super
ADIP-v3 (step 6750), linear merge λ=0.4 into Qwen3-Embedding-0.6B	A-lin0.4	ADIP merge	eng	eng: 41	not used
ADIP-v3 (step 6750), linear merge λ=0.5 into Qwen3-Embedding-0.6B	A-lin0.5	ADIP merge	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
ADIP-v3 (step 6750), linear merge λ=0.6 into Qwen3-Embedding-0.6B	A-lin0.6	ADIP merge	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
ADIP-v3+v4: ADIP-v3 (final) + ADIP-v4, TIES d=0.1 λ=0.5 into Qwen3-Embedding-0.6B	FV-ties-d0.1-l0.5	ADIP merge	ara	ara: 42	ara-super
ADIP-v3+v4: ADIP-v3 (final) + ADIP-v4, TIES d=0.3 λ=0.7 into Qwen3-Embedding-0.6B	FV-ties-d0.3-l0.7	ADIP merge	ara	ara: 42	ara-super
ADIP-v3+v4: ADIP-v4, linear merge λ=0.4 into Qwen3-Embedding-0.6B	Vq-lin0.4	ADIP merge	ara	ara: 42	ara-super
ADIP-v3+v4: ADIP-v4, linear merge λ=0.6 into Qwen3-Embedding-0.6B	Vq-lin0.6	ADIP merge	ara	ara: 42	ara-super
ADIP-v3+v4: ADIP-v4, linear merge λ=0.7 into Qwen3-Embedding-0.6B	Vq-lin0.7	ADIP merge	ara	ara: 42	ara-super
ADIP-v4 (stage 1), linear merge λ=0.5 into ADIP-Embedding-v1-0.6B	S-lin0.5	ADIP merge	eng	eng: 41	eng, eng-super
ADIP-v4, TIES d=0.1 λ=0.5 into ADIP-Embedding-v1-0.6B	V-ties-d0.1-l0.5	ADIP merge	eng	eng: 41	eng, eng-super
ADIP-v4, linear merge λ=0.1 into ADIP-Embedding-v1-0.6B	V-lin0.1	ADIP merge	ara	ara: 42	ara-super
ADIP-v4, linear merge λ=0.3 into ADIP-Embedding-v1-0.6B	V-lin0.3	ADIP merge	eng	eng: 41	not used
ADIP-v4, linear merge λ=0.5 into ADIP-Embedding-v1-0.6B	V-lin0.5	ADIP merge	eng/ara	eng: 41, ara: 42	ara-super
ADIP-v4, linear merge λ=0.7 into ADIP-Embedding-v1-0.6B	V-lin0.7	ADIP merge	eng	eng: 41	eng, eng-super
ADIP-v4, linear merge λ=1.0 into ADIP-Embedding-v1-0.6B	V-lin1.0	ADIP merge	ara	ara: 42	ara-super
ADIP-v5 (stage 1), linear merge λ=0.5 into ADIP-Embedding-v1-0.6B	S5-lin0.5	ADIP merge	eng/ara	eng: 41, ara: 42	eng, eng-super, ara-super
ADIP-v5, TIES d=0.3 λ=0.7 into ADIP-Embedding-v1-0.6B	V5-ties-d0.3-l0.7	ADIP merge	eng	eng: 41	eng, eng-super
ADIP-v5, linear merge λ=0.3 into ADIP-Embedding-v1-0.6B	V5-lin0.3	ADIP merge	eng	eng: 41	not used
ADIP-v5, linear merge λ=0.5 into ADIP-Embedding-v1-0.6B	V5-lin0.5	ADIP merge	eng	eng: 41	not used
ADIP-v5, linear merge λ=0.7 into ADIP-Embedding-v1-0.6B	V5-lin0.7	ADIP merge	ara	ara: 42	ara-super
ADIP-v5, linear merge λ=1.0 into ADIP-Embedding-v1-0.6B	V5-lin1.0	ADIP merge	ara	ara: 42	ara-super

Validation

Validation is leave-one-out, with selection and calibration redone without the held-out models:

• family-level LOMO holds out a whole model family at a time. This is the honest test of generalisation to a new kind of model.
• distinct-model LOMO holds out one reference model at a time.

We report the Kendall tau / Pearson / MAE between the estimated and the true benchmark macro and mean (x100) for the held-out models that have full scores on all tasks. "Resolvable pairs" are model pairs whose true scores differ by at least 0.5 points. The baselines are K uniformly random items (metrics averaged over 10 single draws) and the whole candidate pool, which is the ceiling for any subset of it. Per-task tables are in validation/.

eng (K = 100, selection v2; chosen variant anchor/mean+anchorset)

protocol	estimate	macro tau	macro tau (resolvable pairs)	macro Pearson	macro MAE	mean tau	mean MAE	held-out models
family-level LOMO	MTEB-lite	0.852	0.950	0.992	0.44	0.894	0.47	20
family-level LOMO	random K (single draw)	0.833	0.897	0.989	0.39	0.862	0.47	20
family-level LOMO	whole candidate pool	0.892	0.937	0.994	0.17	0.860	0.21	20
distinct-model LOMO	MTEB-lite	0.881	0.950	0.989	0.42	0.934	0.43	20
distinct-model LOMO	random K (single draw)	0.848	0.901	0.989	0.38	0.868	0.45	20
distinct-model LOMO	whole candidate pool	0.881	0.925	0.994	0.16	0.860	0.21	20

eng-super (K = 20, selection v3; chosen variant fisher/mean+anchorset)

protocol	estimate	macro tau	macro tau (resolvable pairs)	macro Pearson	macro MAE	mean tau	mean MAE	held-out models
family-level LOMO	MTEB-lite	0.875	0.930	0.976	0.97	0.869	1.18	35
family-level LOMO	random K (single draw)	0.861	0.918	0.975	1.10	0.885	1.27	35
family-level LOMO	whole candidate pool	0.939	0.974	0.993	0.25	0.918	0.35	35
distinct-model LOMO	MTEB-lite	0.882	0.919	0.975	1.00	0.886	1.18	35
distinct-model LOMO	random K (single draw)	0.862	0.916	0.975	1.08	0.889	1.25	35
distinct-model LOMO	whole candidate pool	0.939	0.974	0.993	0.24	0.918	0.35	35

ara-super (K = 20, selection v4; chosen variant anchor/gp+strat)

protocol	estimate	macro tau	macro tau (resolvable pairs)	macro Pearson	macro MAE	mean tau	mean MAE	held-out models
family-level LOMO	MTEB-lite	0.732	0.824	0.992	1.43	0.772	0.88	37
family-level LOMO	random K (single draw)	0.711	0.804	0.989	1.36	0.764	0.99	37
family-level LOMO	whole candidate pool	0.802	0.890	0.997	0.48	0.835	0.23	37
distinct-model LOMO	MTEB-lite	0.743	0.837	0.992	1.39	0.814	0.87	37
distinct-model LOMO	random K (single draw)	0.713	0.805	0.989	1.36	0.776	0.98	37
distinct-model LOMO	whole candidate pool	0.805	0.890	0.997	0.50	0.838	0.22	37

Limitations

• The reference set is dominated by Qwen3-Embedding-based models: our merges of fine-tuned Qwen3-Embedding-0.6B and the Qwen base models, plus the public models listed above. The calibration is linear, so estimates for very different models are extrapolations. Expect the ranking to be more reliable than the absolute scores.
• Set-level tasks (STS Spearman, pair-classification AP, clustering V-measure) are not sums over items, so per-item IRT does not apply. They are scored as sets on anchor points of per-item outcomes. Clustering with 20 items is very noisy.
• Weakly calibrated tasks (in-sample fit r < 0.3; their estimates stay close to the reference-model mean, so they add little ranking signal). A constant subset statistic, e.g. 20 clustering items over hundreds of labels where every item is its own cluster, gives r = 0: eng-super: BiorxivClusteringP2P.v2 (r=0.22), MindSmallReranking (r=0.26), StackExchangeClustering.v2 (r=nan), StackExchangeClusteringP2P.v2 (r=-0.00), TwitterURLCorpus (r=0.06); ara-super: SIB200ClusteringS2S (r=nan), SemRel24STS (r=0.04)
• Pool ceiling. Items come from candidate pools: up to 1,000 queries per retrieval task with BM25-30 candidates + random documents, and up to 1,000 items per other task. A retrieval query is scored against its candidate set, not the full corpus. Even the whole pool only reaches the tau in the "whole candidate pool" rows. Much of the residual tau error comes from near-tied models (less than 0.5 points apart); see the resolvable-pairs column.
• Main-score families. Pair-classification main scores are max-AP over similarity functions; the subsets use cosine AP and rely on calibration. Bitext mining uses nearest-neighbour accuracy against fixed distractors in place of mteb's F1.

License

This repository ships only ids, weights, coefficients and code. Each task's data remains under its source dataset's license, and mteb_lite.py downloads it from the original source at evaluation time. Code: Apache-2.0.

Citation

@misc{mteb_lite_2026,
  title  = {MTEB-lite: validated small subsets of MTEB(eng, v2) and Arabic MMTEB},
  author = {ADIP team, QCRI},
  year   = {2026},
  note   = {https://huggingface.co/datasets/ADIP-QCRI/MTEB-lite}
}

Please also cite MTEB / MMTEB and the source datasets of the tasks you report.

Contact

easgari@hbku.edu.qa