Jina Embeddings v3 Pricing &
Late Chunking Cost Calculator
Priced at just $0.02 per 1M tokens with 8,192 context, 89 languages, and 5 task-specific LoRA adapters. Analyze cloud API vs self-hosted GPU economics.
Jina Cloud API vs Self-Hosted GPU Calculator
Determine the exact monthly token threshold where self-hosting on a cloud GPU ($0.60/hr L4 instance) becomes cheaper than Jina's $0.02/M API.
1. Jina Embeddings v3 Specifications
Built on a 570M parameter modern transformer backbone with RoPE position encodings and FlashAttention-2:
| Specification | Jina Embeddings v3 | OpenAI text-embedding-3-small | Cohere Embed v3 |
|---|---|---|---|
| API Price / 1M Tokens | $0.02 | $0.02 | $0.10 |
| Max Context Window | 8,192 tokens | 8,191 tokens | 512 tokens |
| Output Dimensions | 1,024 (down to 256 via Matryoshka) | 1,536 (down to 512) | 1,024 |
| Task-Specific Adapters | 5 LoRA Adapters built-in | None (general) | Search doc vs Search query |
| Late Chunking Support | Native 1st-class implementation | No | No |
| Open Weights / Self-Hostable | Yes (Hugging Face) | No (Proprietary API only) | No (Proprietary API / Cloud only) |
2. How Late Chunking Fixes Chunk Boundary Loss
In standard RAG chunking, if chunk #1 mentions “Apple announced the M4 chip yesterday” and chunk #2 begins with “It achieves 25% faster single-thread performance”, chunk #2 loses the reference to “Apple” and “M4” completely.
Late Chunking processes the entire 8,192-token document through the model's self-attention layers first. Every word attends to every other word in the entire document. Afterward, mean pooling is applied across the character boundaries of each chunk. Chunk #2 retains the full semantic weight of chunk #1 without messy text overlap duplication.
Frequently Asked Questions
Task-Specific LoRA Adapters, FlashAttention-2 & 8192 Context Window Economics
Jina Embeddings v3 (`jina-embeddings-v3`) introduces a paradigm shift in dense semantic retrieval: rather than training a monolithic generalist model or relying on brittle prompt prefixes, Jina v3 integrates task-specific Low-Rank Adaptation (LoRA) heads directly into its 570M parameter transformer architecture. By passing a simple `task` parameter (`retrieval.passage`, `retrieval.query`, `classification`, `text-matching`, or `separation`), the model activates specialized attention projections optimized for that specific downstream task across 8,192 token sequences.
Jina Embeddings v3 Task Adapters & MTEB Performance
| LoRA Task Mode | Dimension Size | MTEB English Score | Multilingual Retrieval | Target Use Case |
|---|---|---|---|---|
| retrieval.passage | 1024-dim (MRL 256-1024) | 65.4% | 68.2% | Document chunk indexing |
| retrieval.query | 1024-dim (MRL 256-1024) | 65.4% | 68.2% | Asymmetric search queries |
| classification | 1024-dim | 78.1% | 74.5% | Linear probe intent classification |
| text-matching | 1024-dim | 85.2% | 82.0% | Semantic deduplication & clustering |
HuggingFace Transformers Python Ingestion Pipeline
Encode document passages with FlashAttention-2 and specific LoRA task adapters:
from transformers import AutoModel
import torch
model = AutoModel.from_pretrained(
"jinaai/jina-embeddings-v3",
trust_remote_code=True,
torch_dtype=torch.bfloat16
).to("cuda")
texts = ["Distributed system architecture and consensus algorithms in PostgreSQL."]
embeddings = model.encode(texts, task="retrieval.passage", truncate_dim=512)
print(f"Generated MRL 512-dim embedding: {embeddings.shape}")Self-Hosting Economics vs Jina Cloud API
Jina AI offers cloud API tokens at $0.02 per million tokens. Because the underlying model has only 570M parameters, self-hosting Jina v3 on a single NVIDIA L4 GPU instance ($0.45/hour) processes over 6,500 tokens per second. For organizations indexing more than 100 million tokens monthly, self-hosting achieves a full infrastructure breakeven while retaining complete control over sensitive enterprise data.
FlashAttention-2 Kernel Sizing & 8k Context Scaling
Jina Embeddings v3 incorporates FlashAttention-2, reducing attention computational complexity from quadratic $O(N^2)$ to linear memory scaling across long 8,192 token sequences. In self-hosted PyTorch environments, enabling bfloat16 precision and chunked forward passes pushes single-GPU embedding throughput past 5,200 tokens per second on NVIDIA L4 or RTX 4090 accelerators.
Pairing Jina v3 passage embeddings with Matryoshka dimension truncation down to 512 dimensions preserves 99.2% of MTEB retrieval accuracy while halving vector storage footprints in production Qdrant clusters.
Jina AI Multi-Region Ingestion & High Availability SLAs
In enterprise cloud environments, configuring multi-region API fallback between Jina AI's European and US cloud endpoints ensures uninterrupted embedding ingestion during external network transit fluctuations, maintaining 99.95% uptime for production semantic search services.
Task-Specific Embeddings: LoRA Adapters & 8,192 Context Window
Jina Embeddings v3 (jina-embeddings-v3) is a breakthrough open-weights text embedding model developed by Jina AI. Unlike conventional embedding models that use a fixed vector projection for all queries, Jina v3 incorporates Task-Specific LoRA Adapters directly into the 570M parameter transformer architecture.
When vectorizing text, developers pass a task identifier: retrieval.query, retrieval.passage, separation, classification, or text-matching. This task conditioning allows Jina v3 to outperform larger models on MTEB while supporting an 8,192-token context window and flexible dimensionality truncation (Matryoshka Representation Learning) down to 256 or 512 dimensions to slash vector database RAM costs.
Jina AI API Pricing & Model Specs
| Feature / Parameter | Jina Embeddings v3 | OpenAI text-embedding-3-large |
|---|---|---|
| Price per 1M Tokens | $0.02 / 1M tokens (84% Cheaper) | $0.13 / 1M tokens |
| Free Onboarding Allotment | 10,000,000 free tokens on signup | None |
| Task-Specific Adapters | Native LoRA Task Adapters | Fixed embedding space |
| Open Weights & Self-Hosting | 100% Open Weights (Apache 2.0) | Closed proprietary SaaS only |