jina-embeddings-v5-text-small

jina-embeddings-v5-text-small is a dense, multilingual text embedding model with 0.596B parameters, developed by Jina AI and released on February 18, 2026. It is the mid-size entry in the jina-embeddings-v5 family, sitting between the nano (239M) and any future full-size variant. The model is built on a Qwen3-0.6B-Base backbone and uses a two-stage training pipeline: knowledge distillation from a much larger Qwen3-Embedding-4B teacher, followed by task-specific contrastive fine-tuning with four dedicated LoRA adapters.

What sets this model apart is its ability to deliver state-of-the-art performance on MTEB English v2 (71.7 average) and MMTEB (67.7) for a model under 1B parameters. It supports 119+ languages natively, produces 1024‑dimensional embeddings via last-token pooling, and handles context lengths up to 32,768 tokens — a significant jump from earlier sub‑1B embedding models.

This is a practical, lightweight choice for developers who need strong multilingual retrieval, clustering, or classification on local hardware. It competes directly with models like jina-embeddings-v3 (570M) and bge-m3 (570M), but offers a better performance-per-parameter ratio thanks to its distillation‑based training.

The model uses a standard dense transformer architecture with the following key specifications:

• Embedding dimension: 1024 (default) with Matryoshka dimensions at 32, 64, 128, 256, 512, 768, and 1024. You can truncate the output vector to any of these dimensions without retraining, trading off storage/bandwidth for precision.
• Pooling: Last-token pooling. The model is trained to take the hidden state of the final token in the sequence as the embedding. This is computationally efficient compared to mean pooling and works well with long sequences.
• Context window: 32,768 tokens, enabled by rotary positional embeddings (RoPE) with adjusted base frequencies. This allows encoding of long documents, entire articles, or chat histories into a single embedding.
• Position-aware: The model retains some sensitivity to position, making it suitable for tasks like passage re-ranking where the order of tokens matters.
• Adapter architecture: Four independent low-rank adapters (LoRA) are trained on top of the frozen backbone — one each for retrieval, text matching (semantic similarity), clustering, and classification. At inference time you select the task-specific adapter via the API or config.

The model is designed for local deployment. Jina provides GGUF quantized versions (Q2_K through Q8_0) and MLX weights for Apple Silicon. Because the backbone is dense and relatively small (0.596B), even the full-precision (BF16) model fits comfortably within 1.2 GB of VRAM. With 4‑bit quantization (Q4_K_M) the model size drops to ~380 MB, making it feasible on low‑VRAM GPUs and even on modern laptops.

The model is trained for four distinct tasks, each with its own adapter:

• Retrieval: For search, RAG systems, and document ranking. The retrieval adapter is optimized for dot‑product scoring and works well with standard nearest‑neighbor indexes (e.g., FAISS, Annoy).
• Text Matching: Semantic textual similarity (STS) — measuring how similar two texts are, often used in deduplication, question‑answering, or paraphrase detection.
• Clustering: Grouping texts by semantic content, e.g., topic modelling, customer feedback categorization, or document organization.
• Classification Zero-shot or fine-grained text classification via embedding similarity to class prototypes.

Concrete use cases where this model excels:

• Multilingual search across 93+ languages with a single model — no need to switch between language‑specific embedders.
• Long‑document retrieval — encode full PDFs or lengthy reports into a single 1024‑d vector without chunking.
• Edge‑based RAG running on consumer hardware (e.g., RTX 3060, M4 MacBooks) for offline knowledge bases.
• Cross‑lingual similarity — the model handles code‑switching and translations natively, as shown in the official demo comparing Arabic, Chinese, English, French, German, Greek, and Hindi sentences.

The model is not suited for generative tasks or code generation — it is a text‑to‑vector model only.

The model’s small size makes it one of the most accessible sub‑1B embedding models for local inference:

Minimum: A GPU with 2 GB VRAM (e.g., GTX 1060) can run the Q4_K_M variant comfortably. For CPU‑only inference, 4‑bit quantized models run well on any modern x86 processor with AVX2 support.

Recommended: An RTX 4090 or M4 Max will run the BF16 model with throughput exceeding 500 tokens per second on batch sizes of 32. For high‑throughput production on a single GPU, Q8_0 offers the best speed‑quality trade‑off.

1ollama run jina-embeddings-v5-text-small:q4_k_m

This downloads the pre‑quantized GGUF model and exposes a /api/embed endpoint compatible with standard libraries. On a desktop with an RTX 4090, expect 1500–2500 tokens/sec for single‑sequence encoding. On an M4 MacBook Pro, 800–1200 tokens/sec (Q4_K_M with Metal acceleration).

• The model supports batch encoding — batch size 32 improves throughput 8–10× over single‑sequence encoding.
• For very long texts (>8K tokens), consider using the Matryoshka dimensions to reduce embedding size — e.g., drop to 256 dimensions when storage or transmission bandwidth is constrained, with only a 2–3% loss in retrieval accuracy.
• Binary quantization (packing 1024‑d floats into 1024 bits) is supported natively after embedding generation. Jina AI reports robust performance even with binarized embeddings, which can cut storage by 32×.

• Q4_K_M for most local users — best balance of quality, speed, and VRAM usage.
• Q8_0 if you have >1 GB VRAM and want minimal quality loss (especially for classification and clustering tasks).
• Q2_K only for very constrained environments (e.g., mobile or Raspberry Pi) — expect a 5–10% drop in MTEB scores compared to BF16.

vs jina-embeddings-v3 (570M parameters, same provider):

v5-small outperforms v3 on MTEB English v2 by ~3 points and MMTEB by ~2 points, thanks to the distillation‑based training from a 4B teacher. Both models support 119+ languages, but v5 has a longer context window (32K vs 8K) and Matryoshka flexibility. Choose v5-small if you need better retrieval accuracy on long documents; v3 remains a solid option if you rely on its older, well‑tested pipeline.

vs bge-m3 (570M parameters, BAAI):

bge-m3 is a strong multilingual embedding model trained on a massive corpus, with similar performance on MTEB (English) but lower scores on MMTEB. v5-small edges ahead on multilingual tasks and offers the adapter‑based task specialization — you can tune the model for a specific task without retraining the whole backbone. bge-m3 has a slightly smaller embedding dimension (1024 vs 1024 the same) but lacks Matryoshka. For a single‑model solution covering many tasks, v5-small is more flexible; bge-m3 is better if you need a no‑frills, well‑documented drop‑in replacement for existing systems.

In summary, jina-embeddings-v5-text-small delivers best‑in‑class efficiency for local multilingual embedding workloads. Its 0.596B size, 32K context, and task adapters make it a practical choice for developers who need high accuracy without cloud dependencies.