jina-embeddings-v5-text-nano

jina-embeddings-v5-text-nano is a 239M parameter multilingual text embedding model from Jina AI, released February 18, 2026. It is the smallest member of the jina-embeddings-v5 family, distilled from the much larger Qwen3-Embedding-4B onto a EuroBERT-210M backbone. Despite its compact size, it scores 71.0 on MTEB English v2 and 65.5 on MMTEB—matching or exceeding models more than twice its parameter count, such as KaLM-mini-v2.5 (494M) and Gemma-300M (308M).

This model is purpose-built for retrieval, text matching, clustering, and classification tasks where latency and memory are constrained. It replaces the need for cloud API calls by running efficiently on consumer hardware, making it a strong choice for local RAG pipelines, semantic search, and multilingual document processing on edge devices. The license is CC-BY-NC-4.0, which restricts commercial use but permits research, prototyping, and internal development.

jina-embeddings-v5-text-nano uses a dense architecture with 0.212B total parameters (239M). It is built on EuroBERT-210M, a bidirectional encoder pretrained on 15 major European and global languages. The model produces 768-dimensional embeddings via last-token pooling and supports a maximum sequence length of 8192 tokens.

Key architectural features:

• Matryoshka Representation Learning: Embeddings can be truncated to 32, 64, 128, 256, 512, or 768 dimensions. This allows you to trade off accuracy for speed and memory at inference time without re-embedding.
• Task-specific LoRA adapters: Four lightweight adapters (6.7M parameters each) are available for retrieval, semantic similarity, clustering, and classification. You load the base model once and swap adapters per task—no full fine-tuning required.
• Robust under truncation and binary quantization: The embeddings maintain quality even when inputs are cut short or when you quantize to binary (1-bit) for extreme memory savings.
• Training recipe: The model was trained by combining embedding distillation from Qwen3-Embedding-4B with task-specific contrastive losses. This yields a small model that captures the teacher’s representational quality while retaining task-specific focus.

jina-embeddings-v5-text-nano is a text-only embedding model that handles 108 languages, with primary training on 32 languages. It is designed for four core tasks:

• Retrieval: Semantic search and first-stage retrieval in RAG systems. The model maps queries and documents into a shared dense space, enabling efficient nearest-neighbor search.
• Text Matching: Duplicate detection, paraphrase identification, and similarity scoring for pairs of texts.
• Clustering: Grouping documents, messages, or logs by topic or content similarity.
• Classification: Zero-shot or adapter-based classification, ideal for routing, tagging, and moderation.

Concrete use cases include local RAG on a laptop for research papers, multilingual semantic search on customer support archives, and topic clustering for social media monitoring. Because the model is small, it can run alongside larger LLMs in a pipeline without consuming excessive VRAM. Note that it does not process images or audio—strictly text.

This model is built for local deployment on consumer-grade hardware. Its small size makes it one of the few embedding models that fits comfortably on integrated GPUs and even some CPUs with acceptable throughput.

• Consumer NVIDIA GPUs: Runs on any GPU with at least 2GB VRAM. RTX 3060 (12GB), RTX 4070 (12GB), RTX 4090 (24GB) all handle the model easily. Batch inference of hundreds of embeddings is feasible.
• Apple Silicon: MLX quantization is available. M1, M2, M3, and M4 chips (including Max variants) can serve the model at high throughput. An M4 Max can process ~500–800 tokens/sec.
• Integrated / CPU: With Q4_K_M quantization, the model runs on 8GB RAM systems (e.g., Intel Core ultra-laptops) at slower speeds (~50–100 tokens/sec), sufficient for offline batch processing.

For most local deployments, use Q4_K_M (GGUF) or the equivalent MLX 4-bit quant. This preserves near-FP16 accuracy while cutting VRAM usage by over 60%. If you need maximum throughput and have ample VRAM, FP16 is safe. Binary quantization (1-bit) is supported but only recommended for retrieval tasks where speed is critical and recall is secondary.

On an RTX 4090, expect >1000 tokens/sec for a single sequence, scaling linearly with batch size. On an M4 Pro, ~600 tokens/sec. On a desktop CPU (AVX2 support), ~80 tokens/sec with Q4_K_M.

The fastest way to evaluate the model locally is via Ollama (if supported) or directly through transformers with peft:

1from transformers import AutoModel
2model = AutoModel.from_pretrained("jinaai/jina-embeddings-v5-text-nano", trust_remote_code=True)

For Elasticsearch users, the model is also available through Elastic Inference Service (EIS), which provides managed inference within your cluster.

• Performance: jina-embeddings-v5-text-nano scores higher on MTEB (71.0 vs. ~69) despite having half the parameters.
• Context length: Both support 8K tokens.
• Languages: KaLM-mini-v2.5 is primarily English-focused; the Jina model is natively multilingual (108 languages).
• Tradeoff: The Jina model uses a non-commercial license. If you need commercial use, KaLM-mini-v2.5 (Apache 2.0) may be preferable.

• Performance: Comparable MTEB scores, but Jina nano is 23% smaller and supports matryoshka dimensions.
• Ecosystem: Gemma-300M is part of Google’s open ecosystem (Apache 2.0) and has broader community support. The Jina model’s format is well-supported by sentence-transformers and GGUF.
• Use case: If you need task-specific adapters (retrieval, clustering) without fine-tuning, the Jina model’s LoRA approach is a clear advantage.

• You need a very small embedding model (<300M params) for latency-sensitive applications.
• You work with multilingual text and cannot compromise on cross-lingual retrieval quality.
• You want task-specific adapters for classification or clustering without maintaining multiple full-size models.
• Your use case falls under non-commercial research or internal prototyping.

If you need commercial licensing or require a larger context window (32K tokens), consider jina-embeddings-v5-text-small (677M) or the Apache-licensed intfloat/multilingual-e5-small.