bekko-static-v1-slim-100k

bekko-static-v1-slim-100k

Turns text into 1024-dimension vectors with a static embedding model, trimmed to 25 languages. Fast sentence similarity and retrieval, without a transformer, in Python or Rust.

Made by flowercomputers on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: bekko-static-v1-slim-100k is a static embedding model. It looks up each token in a table and averages the results, with no transformer, so text becomes a 1024-dimension vector quickly. It is a trimmed copy of bekko-static-embedding-v1 that keeps half of the 200,000 tokens.

Who it suits: It suits developers who build search or similarity features and want small, fast embeddings across 25 languages, from English and Arabic to Yoruba and Chinese.

Title: Who runs it
Industry | Who uses it | How they use it | Example
Software | Search developers | Embed documents and queries for retrieval | Rank help articles against a question
Research | Retrieval researchers | Test embedding quality against vocabulary size | Compare the family's builds on NanoBEIR
Embedded systems | Rust developers | Compile the embedder into a program | A search feature with no runtime download

If you need languages outside the 25, you can skip it, since their tokens were removed.

Where to use it:

• Python with the sentence-transformers library, on Windows, macOS or Linux
• Rust programs, through the encoders crate
• Retrieval and similarity jobs over text in the 25 supported languages

Title: Jobs it does
Use case | Who | What they get back
Sentence similarity | Developers | A similarity score between two texts
Document retrieval | Search teams | Vectors you can rank by closeness
Smaller vectors | Storage-minded teams | Shorter embeddings by cutting the width

How to set it up:

• Python with sentence-transformers, or a Rust project that uses the encoders crate
• No prompts or prefixes are needed for queries or documents

1. Install sentence-transformers if you use Python.
2. Load the model by name in your code.
3. For Rust, add the encoders crate with this model's feature.

pip install -U huggingface_hub
hf download flowercomputers/bekko-static-v1-slim-100k

$ cargo add encoders --features='bekko-static-v1-slim-100k'

How to use it: Encode your texts and compare the vectors. Pass a smaller width, such as 256, to get a shorter Matryoshka embedding. In Rust, call the encode functions on one string or a batch.

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("flower-computer/bekko-static-v1-slim-100k")           # add truncate_dim=256 etc. for Matryoshka sizes
emb = model.encode(["What is the capital of France?", "Paris is the capital of France."])
print(model.similarity(emb[0:1], emb[1:2]))

let one   = encoders::encode_single("What is the capital of France?");
let batch = encoders::encode(["Paris is the capital of France.", "Tokyo is the capital of Japan."]);

Title: Rust crate options
Tool | What it does
mrl-512 to mrl-32 | Cut the vectors to a Matryoshka width, with 1024 as the default
int8, int16, float32 | Choose the table type, where int16 is the default
rayon | Runs batches in parallel

Example: You encode a question and a sentence that answers it, such as the capital of France. The code prints one similarity score for the pair, and a matching answer should score higher than an unrelated sentence.

For newcomers and experts: If you are new, an embedding turns a sentence into a list of numbers so a program can tell how close two sentences are in meaning. The first small thing to try is the Python snippet with two sentences.

If you know the field, the model uses token lookup and mean pooling at 1024 dimensions, with widths from 32 to 1024. The trade-off is quality for size: with this 100k vocabulary, NanoBEIR-en drops from 53.71 to 52.91 and the file halves to 205 MB.

Text is split into WordPiece tokens
Each token is looked up in a table
Vectors are averaged into one embedding
Compare embeddings for similarity

Good to know:

Title: NanoBEIR-en score by vocabulary size
200k, source model: 53.71
100k, this model: 52.91
75k: 52.09
50k: 50.22
32k: 49.31

• Languages: text in languages outside the 25 is not supported and falls back to characters or an unknown token.
• Size: about 205 MB in F16, against 410 MB for the source model.
• License: mit.
• Cost to run: no API key, account or paid service is named.
• Data it reaches: Python downloads the model from Hugging Face. The Rust crate compiles it in, so there is no runtime download.
• Not for: languages outside the 25 it covers.

On Hugging Face, 13 November 2026

• Task: sentence similarity
• Library: sentence-transformers
• Parameters: 102M
• Weights: about 205 MB in F16; about 51 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 0
• Likes: 3
• License: mit
• Languages: en, ar, bn, de, es, fa, fi, fr
• Based on: hotchpotch/bekko-static-embedding-v1
• Tags: sentence-transformers, safetensors, static-embedding, sentence-similarity, feature-extraction, vocabulary-pruning, multilingual

Links

• Model: https://huggingface.co/flowercomputers/bekko-static-v1-slim-100k
• Files: https://huggingface.co/flowercomputers/bekko-static-v1-slim-100k/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download flowercomputers/bekko-static-v1-slim-100k

Then follow the usage in its model card. Nothing in this kit runs by itself.