bekko-embedding-v1-a25m

bekko-embedding-v1-a25m is an ultra-compact multilingual text embedding model. It has just 25M active parameters — light enough to run comfortably on modest CPUs — yet its retrieval quality is comparable to models with 3–10x more active parameters.

For a smaller, faster model, see bekko-embedding-v1-a8m (8M active parameters).

You can also try bekko right in your browser: the bekko-embedding-web demo runs the model fully client-side with Transformers.js — no server involved.

[!NOTE] For a guided overview of the models, training recipe, and results, read Bekko Embedding: how small can a multilingual retrieval model be?.

Highlights

• Ultra-compact: just 25M active parameters, with retrieval quality on par with models 3–10x its active-parameter count
• 100+ languages, context up to 8k tokens
• 384-dim embeddings that truncate cleanly to 256 / 128 / 64 (Matryoshka)
• Runs well on CPU — even a Raspberry Pi 5 — with ONNX and OpenVINO artifacts included
• Fast on GPU too, with SDPA or Flash Attention 2
• MIT license

a8m or a25m?

Rule of thumb: a25m is the quality pick. Switch to a8m when CPU budget or latency is tight — it keeps most of the quality and gains about 2.7x CPU throughput.

Quickstart

We recommend Sentence Transformers 5.0+ and Transformers 5.12+:

pip install -U "sentence-transformers>=5.0" "transformers>=5.12"

Queries and documents go through the same encode() call — no prefixes or task instructions needed. Pass normalize_embeddings=True when you plan to search with cosine similarity or dot product.

On GPU, SDPA works out of the box with PyTorch and CUDA. Flash Attention 2 requires pip install flash-attn --no-build-isolation; on our RTX 5090 it was about 24% faster, and can be enabled by replacing "sdpa" below with "flash_attention_2". Sentence Transformers selects CUDA automatically, so device is normally unnecessary; to force it, use device="cuda", not "gpu".

from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer(
    "hotchpotch/bekko-embedding-v1-a25m",
    # model_kwargs={"attn_implementation": "sdpa"},  # Optional on GPU
)

query = "What are the characteristics of sushi?"
docs = [
    "A warm noodle soup served in broth with sliced toppings.",
    "天ぷらは魚や野菜に衣をつけて揚げた料理です。",  # "Tempura is battered, deep-fried fish and vegetables."
    "Une fine crepe garnie de sucre, de beurre ou de fruits.",
    "A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.",
]

query_emb = model.encode(query, normalize_embeddings=True)
doc_emb = model.encode(docs, normalize_embeddings=True)
scores = util.cos_sim(query_emb, doc_emb)[0]

print(scores)
print("best doc:", docs[int(scores.argmax())])

Output (exact scores vary slightly by backend):

tensor([0.2953, 0.2785, 0.3209, 0.4378])
best doc: A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.

Queries and documents don't need to share a language. Continuing with the same model, a Japanese query finds the right English document in a mixed English / Spanish corpus:

corpus = [
    "Sushi is a Japanese dish of vinegared rice topped with seafood.",
    "The Eiffel Tower is a wrought-iron lattice tower in Paris, France.",
    "Mount Fuji is the highest mountain in Japan, at 3,776 meters.",
    "Python is a programming language known for its readability.",
    "La Sagrada Família es una basílica de Barcelona diseñada por Antoni Gaudí.",
]
corpus_emb = model.encode(corpus, normalize_embeddings=True)

for query in [
    "日本で一番高い山は？",  # "What is the highest mountain in Japan?"
    "Who designed the famous basilica in Barcelona?",
]:
    query_emb = model.encode(query, normalize_embeddings=True)
    hits = util.semantic_search(query_emb, corpus_emb, top_k=2)[0]
    print(query)
    for hit in hits:
        print(f"  {hit['score']:.3f}  {corpus[hit['corpus_id']]}")

日本で一番高い山は？
  0.457  Mount Fuji is the highest mountain in Japan, at 3,776 meters.
  0.142  Sushi is a Japanese dish of vinegared rice topped with seafood.
Who designed the famous basilica in Barcelona?
  0.563  La Sagrada Família es una basílica de Barcelona diseñada por Antoni Gaudí.
  0.126  The Eiffel Tower is a wrought-iron lattice tower in Paris, France.

That's everything you need for basic use. For more speed — OpenVINO on CPU, Flash Attention on GPU, browser inference, smaller embeddings — see Optimized Inference below.

Benchmark results

In the chart above, up and to the left is better: more retrieval quality from fewer active parameters. The step line shows the best observed score within each active-parameter budget, and outlined markers identify Pareto-efficient models. Both bekko models sit in that upper-left region, scoring at or above many models several times their size — which is the whole point of the project.

On the 131-task MMTEB Multilingual v2 suite, a25m scores 57.5 Retrieval and 58.3 Mean(Task) with 24.9M active parameters. That edges out gte-multilingual-base on Retrieval and ties it on Mean with ~4.5x fewer active parameters, and beats multilingual-e5-large and BGE-M3 on Retrieval with ~12x fewer.

Scores are ×100. Retrieval is task-macro nDCG@10, and Mean is the mean across all 131 tasks. Competitor values use the official 2026-06-28 snapshot. Bekko was evaluated over the same task set and aggregation rules.

Scores are ×100. a25m is stronger than a8m on 13 of 18 tasks and on the mean. Its main regression is WinoGrande.

Abbreviations: mE5-s = multilingual-e5-small, G97 = Granite Embedding 97M Multilingual R2, GTE = gte-multilingual-base, MIRACL HN = MIRACL Retrieval Hard Negatives.

The following retrieval scores use multilingual Nano benchmarks measured with HAKARI-Bench. Higher is better.

What each column means:

• Overall — HAKARI-Bench Overall, the micro-average across all the sets below
• MNanoBEIR — multilingual NanoBEIR, general-purpose retrieval
• NanoMMTEB-v2 — Nano subset of MMTEB v2 (massive multilingual retrieval)
• NanoRTEB — multilingual retrieval benchmark
• NanoLongEmbed — long-document retrieval
• NanoCoIR — code retrieval

Scores are nDCG@10. a25m scores higher than a8m on 14 of 18 tasks. Its slightly lower simple mean is mainly due to LEMBPasskey.

Model abbreviations match the Full MMTEB Retrieval table above.

Model Details

Why active parameters?

The "a25m" in the name counts active parameters: the attention and feed-forward weights that run on every token, which is where nearly all of a transformer encoder's inference cost lives. The token embedding table dominates the total parameter count, but at inference it's only a lookup.

That's why a model can be large on disk and still fast. bekko-embedding-v1-a25m totals ~123M parameters, but the bulk of that is the multilingual embedding table — only 25M parameters do real work per token, so latency behaves like a 25M model. The default OpenVINO / ONNX artifacts also store that static table as row-wise int8, cutting the main model file from about 470 MiB to 190 MiB.

Speed vs other models

On a Ryzen 9 7950X with OpenVINO, a25m encodes 134 docs/s — about 6.4x multilingual-e5-large. On an RTX 5090 with Flash Attention 2 it reaches 4,006 docs/s, faster than every model we measured except a8m.

Document throughput uses Natural Questions text, batch size 64 and max length 512 for CPU/MPS. CUDA uses NQ 100k, fp16, and Flash Attention 2. All throughput values in the table are docs/s.

Abbreviations: mE5 = multilingual-e5, granite-97m/311m-r2 = Granite Embedding Multilingual R2, EmbGemma = EmbeddingGemma. x86 = Ryzen 9 7950X + OpenVINO, Pi 5 = Raspberry Pi 5 + OpenVINO, M4 = Apple M4 Max + MPS, RTX = RTX 5090 + CUDA/Flash Attention 2. AP means active parameters.

Throughput depends on input lengths, batch size, runtime, and hardware. OpenVINO is recommended for CPU, MPS for Apple Silicon, and Flash Attention 2 for supported NVIDIA GPUs.

Optimized Inference

Choose the backend based on where you run the model:

For native CPU inference, we do not recommend ONNX Runtime; use OpenVINO instead. Keep ONNX for browser deployment or environments that specifically require it. The default OpenVINO and ONNX artifacts both keep the tokenizer and vocabulary untouched and compress only the static token embedding table.

SDPA works everywhere and is the safe default. If your GPU supports Flash Attention 2, it's worth enabling: on our RTX 5090 it was about 24% faster than SDPA for a25m (18% for a8m).

import torch
from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer(
    "hotchpotch/bekko-embedding-v1-a25m",
    device="cuda",
    model_kwargs={
        "attn_implementation": "flash_attention_2",
        "dtype": torch.float16,
    },
)

query = "What are the characteristics of sushi?"
docs = [
    "A warm noodle soup served in broth with sliced toppings.",
    "天ぷらは魚や野菜に衣をつけて揚げた料理です。",  # "Tempura is battered, deep-fried fish and vegetables."
    "Une fine crepe garnie de sucre, de beurre ou de fruits.",
    "A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.",
]

scores = util.cos_sim(
    model.encode(query, normalize_embeddings=True),
    model.encode(docs, normalize_embeddings=True),
)[0]
print(scores)

If Flash Attention 2 is unavailable, use model_kwargs={"attn_implementation": "sdpa"}.

from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer(
    "hotchpotch/bekko-embedding-v1-a25m",
    device="mps",
    model_kwargs={"attn_implementation": "sdpa"},
)

query = "What are the characteristics of sushi?"
docs = [
    "A warm noodle soup served in broth with sliced toppings.",
    "天ぷらは魚や野菜に衣をつけて揚げた料理です。",  # "Tempura is battered, deep-fried fish and vegetables."
    "Une fine crepe garnie de sucre, de beurre ou de fruits.",
    "A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.",
]

scores = util.cos_sim(
    model.encode(query, normalize_embeddings=True),
    model.encode(docs, normalize_embeddings=True),
)[0]
print(scores)

# As of 2026-07-28, Transformers 4.x must be specified so that pip resolves
# a compatible OpenVINO dependency stack.
pip install -U \
  "sentence-transformers[openvino]>=5.0" \
  "transformers>=4.57,<5"

from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer(
    "hotchpotch/bekko-embedding-v1-a25m",
    backend="openvino",
    device="cpu",
    model_kwargs={"file_name": "openvino/openvino_model.xml", "device": "CPU"},
)

query = "What are the characteristics of sushi?"
docs = [
    "A warm noodle soup served in broth with sliced toppings.",
    "A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.",
]
scores = util.cos_sim(
    model.encode(query, normalize_embeddings=True),
    model.encode(docs, normalize_embeddings=True),
)[0]
print(scores)

The default IR is openvino/openvino_model.xml plus .bin, about 190 MiB for the main binary. fp16 and fp32 comparison files are also included with explicit _not_default / _not_recommended names.

For Python ONNX Runtime:

pip install -U "sentence-transformers[onnx]>=5.0"

from sentence_transformers import SentenceTransformer

model = SentenceTransformer(
    "hotchpotch/bekko-embedding-v1-a25m",
    backend="onnx",
    device="cpu",
    model_kwargs={"file_name": "onnx/model.onnx", "provider": "CPUExecutionProvider"},
)
embeddings = model.encode(
    ["What are the characteristics of sushi?", "Sushi uses vinegared rice."],
    normalize_embeddings=True,
)

For Transformers.js:

npm install @huggingface/transformers

import { pipeline } from "@huggingface/transformers";

// Browser: use WebGPU when available, otherwise fall back to WASM.
// Node.js: replace this line with `const device = "cpu";`.
const device = navigator.gpu ? "webgpu" : "wasm";

const extractor = await pipeline(
  "feature-extraction",
  "hotchpotch/bekko-embedding-v1-a25m",
  { device, dtype: "fp32" },
);
const embedding = await extractor("What are the characteristics of sushi?", {
  pooling: "mean",
  normalize: true,
});

console.log(embedding.dims); // [1, 384]

For a complete client-side example, see the bekko-embedding-web Space.

dtype: "fp32" selects onnx/model.onnx. In this repository, that filename is the compact default (static embedding table in int8), while Transformer computation remains fp32. Additional fp16, fp32, and ONNX qint8/quint8 comparison files are included under explicit names. The Transformer-weight quantized files are experimental, not default choices.

These models are trained with Matryoshka representation learning, so you can shrink the 384-dim embeddings to 256, 128, or 64 dimensions by passing truncate_dim. Smaller dimensions reduce index size and speed up similarity search, at a small cost in retrieval quality (see Truncation and Quantization).

from sentence_transformers import SentenceTransformer, util

# Full embedding is 384-dim; 256 / 128 / 64 are supported.
model = SentenceTransformer(
    "hotchpotch/bekko-embedding-v1-a25m",
    truncate_dim=256,
    model_kwargs={"attn_implementation": "sdpa"},
)

query = "What are the characteristics of sushi?"
docs = [
    "A warm noodle soup served in broth with sliced toppings.",
    "天ぷらは魚や野菜に衣をつけて揚げた料理です。",  # "Tempura is battered, deep-fried fish and vegetables."
    "Une fine crepe garnie de sucre, de beurre ou de fruits.",
    "A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.",
]
emb = model.encode(query, normalize_embeddings=True)
print("embedding dim:", emb.shape[-1])
print(util.cos_sim(emb, model.encode(docs, normalize_embeddings=True))[0])

For portable inference with llama.cpp or Ollama, use the GGUF release in bekko-embedding-v1-a25m-GGUF. The GGUF model uses the same 8192-token context, mean pooling, and 384-dimensional L2-normalized embeddings as this model.

Use BF16 on GPUs and Apple Silicon. For CPU inference, use Q8_0; it is smaller and avoids the severe BF16 slowdown on CPUs without native BF16 arithmetic.

With llama.cpp:

llama-server \
  -hf hotchpotch/bekko-embedding-v1-a25m-GGUF:BF16 \
  --embedding --pooling mean --embd-normalize 2 --ctx-size 8192

curl http://localhost:8080/v1/embeddings \
  -H 'Content-Type: application/json' \
  -d '{"model":"bekko","input":"What is the tallest mountain in Japan?"}'

With Ollama:

# Default (BF16): recommended for GPU and Apple Silicon
ollama pull hotchpotch/bekko-embedding-v1-a25m

curl http://localhost:11434/api/embed \
  -d '{"model":"hotchpotch/bekko-embedding-v1-a25m","input":"What is the tallest mountain in Japan?"}'

# Q8_0: recommended for CPU inference
ollama pull hotchpotch/bekko-embedding-v1-a25m:q8_0

Ollama also provides explicit :bf16 and :f16 tags. The Hugging Face GGUF repository publishes BF16, F16, and Q8_0. Lower-bit variants are not published because they provided little file-size reduction for this architecture while reducing embedding fidelity or throughput. See the GGUF model card for the measurements and conversion details.

Other inference methods

Beyond the Sentence Transformers backends above, you can also serve or run the model with:

Text Embeddings Inference (TEI) is Hugging Face's Rust-based serving stack, with official Docker images, dynamic batching, and Prometheus metrics built in.

Before deploying, confirm your TEI version supports this model's encoder architecture, and pick the image tag that matches your target — a CPU image, or a GPU image for your specific architecture. See the TEI image list for current tags.

model=hotchpotch/bekko-embedding-v1-a25m
volume=$PWD/tei-data
# Replace <tag> with the current TEI image for your hardware (CPU, or your GPU arch).
# Add `--gpus all` when using a GPU image.
docker run -p 8080:80 -v "$volume:/data" --pull always \
  ghcr.io/huggingface/text-embeddings-inference:<tag> \
  --model-id "$model"

import requests
import numpy as np

query = "What are the characteristics of sushi?"
docs = [
    "A warm noodle soup served in broth with sliced toppings.",
    "天ぷらは魚や野菜に衣をつけて揚げた料理です。",  # "Tempura is battered, deep-fried fish and vegetables."
    "Une fine crepe garnie de sucre, de beurre ou de fruits.",
    "A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.",
]

q = np.array(requests.post("http://127.0.0.1:8080/embed", json={"inputs": [query]}).json()[0])
d = np.array(requests.post("http://127.0.0.1:8080/embed", json={"inputs": docs}).json())
q = q / np.linalg.norm(q)
d = d / np.linalg.norm(d, axis=1, keepdims=True)
print(d @ q)

Apply mean pooling with pure Transformers.

import torch
import torch.nn.functional as F
from transformers import AutoModel, AutoTokenizer

model_id = "hotchpotch/bekko-embedding-v1-a25m"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModel.from_pretrained(model_id, attn_implementation="sdpa").eval()

def embed(texts):
    batch = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
    with torch.no_grad():
        out = model(**batch).last_hidden_state
    mask = batch["attention_mask"].unsqueeze(-1)
    pooled = (out * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1)
    return F.normalize(pooled, p=2, dim=1)

query = "What are the characteristics of sushi?"
docs = [
    "A warm noodle soup served in broth with sliced toppings.",
    "天ぷらは魚や野菜に衣をつけて揚げた料理です。",  # "Tempura is battered, deep-fried fish and vegetables."
    "Une fine crepe garnie de sucre, de beurre ou de fruits.",
    "A Japanese dish made with vinegared rice, often shaped with seafood, vegetables, or egg.",
]

scores = embed(docs) @ embed([query]).T
print(scores.squeeze(-1))

Truncation and Quantization

How much quality do you trade for a smaller index? For bekko-embedding-v1-a25m: very little at 256 dimensions (-1.4%), progressively more below that. If you quantize the output vectors to int8 or binary, add a rescoring step — it recovers nearly all of the loss.

FAQ

• Do I need a prefix like query: or passage: ? — No. bekko is trained without prefixes, so you encode raw text for both queries and documents. If you come from the multilingual-e5 family, just drop the prefixes.
• Which languages are covered? — 100+ languages, inherited from the mmBERT base model. Coverage is broad but uneven, so evaluate on your own language and domain before deployment (see Limitations).
• Which file should I load for my runtime? — PyTorch: the default safetensors weights. Fastest CPU inference: openvino/openvino_model.xml. Browser / ONNX Runtime: onnx/model.onnx. Files named _not_default / _not_recommended are comparison artifacts, not deployment choices.
• Can I make the embeddings smaller? — Yes — pass truncate_dim=256 (or 128 / 64). See Truncation and Quantization for the quality cost.
• Can it really run in a browser? — Yes. Try the bekko-embedding-web demo — the model runs fully client-side with Transformers.js.

Limitations

• Bekko is optimized primarily for multilingual retrieval. Its strongest MMTEB results are Retrieval, Reranking, BitextMining, and STS. It is not intended to be state of the art across every embedding task category.
• Bekko is a bi-encoder embedding model, not a cross-encoder reranker. MMTEB Reranking scores measure bi-encoder similarity scoring. Use a dedicated cross-encoder when maximum reranking accuracy is more important than throughput.
• Support for 100+ languages reflects training-data coverage. Quality varies by language and domain, so evaluate on your target data before deployment.
• HAKARI-Bench is maintained by the model author and should be read alongside the independently maintained MMTEB suite. Bekko's MMTEB results use the same 131-task set and aggregation rules as the referenced snapshot, but await submission through the official leaderboard pipeline.
• Throughput varies with text lengths, batch size, backend, software versions, and hardware. Use the benchmark figures as comparative measurements, not guaranteed production latency.
• Transformer-weight qint8 artifacts are experimental and can lose retrieval quality or behave differently across CPU architectures. The default ONNX/OpenVINO artifacts only compress the static token embedding table and are the recommended deployment files.

The name "bekko"

bekko (/ˈbek.koː/) is a coined name that joins two pieces of Japanese tradition:

• akabeko (赤べこ) — the red ox that has been cherished in Japan for centuries as a guardian charm, believed to ward off illness and misfortune.
• bekko-iro (鼈甲色) — a beautiful traditional Japanese color: a warm, translucent, amber-like hue.

The name pairs the protective spirit of the red ox with the quiet beauty of this classic amber tone.

Paper

For full technical details, see Bekko Embedding: Parameter-Efficient Multilingual Retrieval with Ultra-Compact Encoders.

Citation

If you use bekko-embedding in your work, please cite:

@misc{tateno2026bekkoembedding,
  title         = {Bekko Embedding: Parameter-Efficient Multilingual Retrieval with Ultra-Compact Encoders},
  author        = {Yuichi Tateno},
  year          = {2026},
  eprint        = {2607.25180},
  archivePrefix = {arXiv},
  primaryClass  = {cs.IR},
  url           = {https://arxiv.org/abs/2607.25180}
}

Training data

Both datasets built for training bekko-embedding are public:

• hotchpotch/bekko-embedding-v1-unsupervised — unsupervised pretraining data.
• hotchpotch/bekko-embedding-hard-negatives — hard negatives for contrastive fine-tuning.

License

MIT License.

Author

Yuichi Tateno @hotchpotch