DakeraAI/gliner-bi-edge-v2.0-int8

gliner-bi-edge

Smallest entity extraction model for Dakera (English) · int8 ONNX by Dakera, the self-hosted memory engine for AI agents

Dakera's int8 build of knowledgator/gliner-bi-edge-v2.0 for fast CPU inference with ONNX Runtime: 64.9 MB of graphs, the same entities as the original. The model is by its original authors; all credit goes to them.

In Dakera

The lightest option, for hosts with little memory: DAKERA_GLINER_MODEL=gliner-bi-edge.

docker run -p 3000:3000 -e DAKERA_ROOT_API_KEY=dk-mykey ghcr.io/dakera-ai/dakera:latest

Quality and speed

Measured through Dakera's own extraction pipeline (threshold 0.5; the public sets with the labels person, organization, location; ONNX Runtime 1.31 with weight prepacking, one CPU thread per pass on an AMD Ryzen 9 7950X):

Set	F1
Dakera chat sentences, English (20; 10 labels)	0.88
Dakera chat sentences, 7 languages (44; 10 labels)	0.64
WNUT-17 (social media, English)	0.62
CoNLL-2003 (news, English)	0.63

MultiCoNER v2 (150 sentences per language):

de	en	es	fr	hi	it	pt	zh
0.40	0.53	0.31	0.41	0.01	0.44	0.36	0.01

Median time per request on the chat set: 0.006 s.

What changed

Built from the original PyTorch checkpoint by build.py (reproducible: the same tools give the same bytes):

• The span head, factored exactly. GLiNER's span head runs two dense layers on every one of words × 12 spans; the first is split into a start part and an end part computed once per word, and the last is folded into the label side. The logits are unchanged (largest difference 3.8e-06); the cost moves from per span to per word.
• 8-bit weights. The encoder's and the heads' weight matrices are block-wise 8-bit (MatMulNBits, block 32, symmetric, int8 arithmetic) and the word-embedding table is int8 per row. Activations stay FP32: quantizing them is what makes the uniformly quantized GLiNER exports find nothing.
• Checked against the original on multilingual probe sentences: logits correlation at least 0.998, 100% of the entities identical.

Usage

This is a bi-encoder: the text goes in without a label prompt, and the labels go in as vectors (labels_embeddings, one row per label) from onnx/labels_encoder.onnx (inputs input_ids, attention_mask from labels_tokenizer.json; output one pooled vector per label). Encode a label once and reuse its vector for every text.

Word splitting: runs of letters, marks and digits (joined by - or _), any other character alone, and each Chinese or Japanese character alone. Spans of up to 12 words; sigmoid over the logits, threshold 0.5. Keep ONNX Runtime's weight prepacking on (the default): without it the 8-bit MatMuls repack their weights on every run, 4–5× slower.

Files

File	Size
onnx/model.onnx	40.0 MB
tokenizer.json	3.6 MB
gliner_config.json	6.0 kB
onnx/labels_encoder.onnx	24.9 MB
labels_tokenizer.json	711.6 kB

SHA-256 checksums

ff3982cbd0a7c3d00187ed26edf4beaf23b532dedd96fe519f5ef874dc7187a2  onnx/model.onnx
2315a8bea85452f3c4e8ce980f7853cac013820238e7776a4e48159037a5f164  tokenizer.json
c86689142dbc54ea629664792054ba2cfb50e798f1c41c2f34d0258fb513b46d  gliner_config.json
1d462dc442f8e3fc3bbc8f75a71ea210f41fb663e492130ff6a4073559325d5f  onnx/labels_encoder.onnx
91f1def9b9391fdabe028cd3f3fcc4efd34e5d1f08c3bf2de513ebb5911a1854  labels_tokenizer.json

Licence and credit

Apache-2.0, the same as the original model (see LICENSE). For what the model does, how it was trained and its evaluation, see the original model card.

@misc{zaratiana2023gliner,
  title={GLiNER: Generalist Model for Named Entity Recognition using Bidirectional Transformer},
  author={Urchade Zaratiana and Nadi Tomeh and Pierre Holat and Thierry Charnois},
  year={2023},
  eprint={2311.08526},
  archivePrefix={arXiv},
  primaryClass={cs.CL}
}

@misc{stepanov2026millionlabelnerbreakingscale,
  title={The Million-Label NER: Breaking Scale Barriers with GLiNER bi-encoder},
  author={Ihor Stepanov and Mykhailo Shtopko and Dmytro Vodianytskyi and Oleksandr Lukashov},
  year={2026},
  eprint={2602.18487},
  archivePrefix={arXiv},
  primaryClass={cs.CL}
}

About Dakera

Dakera is a self-hosted memory engine for AI agents. It gives agents long-term memory that survives sessions: hybrid vector and full-text retrieval, reranking, entity extraction and importance decay, in a single Rust binary that runs on your own servers, with an MCP server for Claude, Cursor and other agents.

docker run -p 3000:3000 -e DAKERA_ROOT_API_KEY=dk-mykey ghcr.io/dakera-ai/dakera:latest

🌐 Website	dakera.ai
📚 Documentation	dakera.ai/docs
💻 GitHub	github.com/Dakera-AI
🚀 Self-hosting (Docker, Kubernetes, Helm)	dakera-deploy
🔌 MCP server	dakera-mcp
🧰 SDKs	Python · TypeScript · Go · Rust
💼 LinkedIn	Dakera AI

Questions or feedback: amine@dakera.ai.