Loading

Jina models

Jina models are designed and trained for search and retrieval workflows. You can use them to create embeddings for text and multimodal semantic similarity search, rerank candidate results to improve the precision of hybrid search and retrieval-augmented generation (RAG) systems, and extract structured content from HTML and complex documents before indexing.

The following tables list the available Jina models and show where each model can be deployed and how you can access it.

Select a deployment or access option to view the corresponding setup and usage instructions.

Note

For models accessed through Elastic Inference Service (EIS), availability may vary by Stack version. For supported models and version requirements, refer to Elastic Inference Service supported models. Cloud marketplace availability can also vary by model and provider.

Text embedding models

Text embedding models convert text into vector embeddings for semantic similarity search.

Model Description Deployment Access
jina-embeddings-v5-text-small Multilingual text embeddings with task-specific adapters. Accepts text input and produces 1024-dimensional vector embeddings. Supports input lengths up to 32K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API
jina-embeddings-v5-text-nano Multilingual embeddings for edge deployment. Accepts text input and produces 768-dimensional vector embeddings. Supports input lengths up to 8K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API
jina-embeddings-v3 Multilingual text embeddings. Accepts text input and produces 1024-dimensional vector embeddings. Supports input lengths up to 8K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API

Performance considerations

  • jina-embeddings-v5-text-small works best on small, medium or large sized fields that contain natural language. For connector or web crawler use cases, this aligns best with fields like title, description, summary, or abstract.
  • Although the model supports an input token length of 32K, consider chunking very large fields to control latency and cost.
  • Larger documents take longer at ingestion time, and inference time per document also increases the more fields in a document that need to be processed.
  • The more fields your pipeline has to perform inference on, the longer it takes per document to ingest.
  • jina-embeddings-v5-text-nano works best on small, medium or large sized fields that contain natural language. For connector or web crawler use cases, this aligns best with fields like title, description, summary, or abstract.
  • Although the model supports an input token length of 8K, consider chunking very large fields to control latency and cost.
  • Larger documents take longer at ingestion time, and inference time per document also increases the more fields in a document that need to be processed.
  • The more fields your pipeline has to perform inference on, the longer it takes per document to ingest.
  • jina-embeddings-v3 works best on small, medium or large sized fields that contain natural language. For connector or web crawler use cases, this aligns best with fields like title, description, summary, or abstract.
  • Although jina-embeddings-v3 supports an input token length of 8K, it's best to limit the input to 2048-4096 tokens for optimal performance. For larger fields that exceed this limit - for example, body_content on web crawler documents - consider chunking the content into multiple values, where each chunk can be under 4096 tokens.
  • Larger documents take longer at ingestion time, and inference time per document also increases the more fields in a document that need to be processed.
  • The more fields your pipeline has to perform inference on, the longer it takes per document to ingest.

Multimodal embedding models convert text, images, video, audio, and documents such as PDF into vector embeddings in a shared vector space.

Model Description Deployment Access
jina-embeddings-v5-omni-small Multimodal embeddings for text, image, audio, video, and PDF. Accepts multimodal input and produces 1024-dimensional vector embeddings. Supports input lengths up to 32K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API
jina-embeddings-v5-omni-nano Compact multimodal embeddings for edge deployment. Accepts multimodal input and produces 768-dimensional vector embeddings. Supports input lengths up to 8K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API
jina-clip-v2 Multilingual multimodal embeddings for text and image retrieval. Accepts text and image input and produces 1024-dimensional vector embeddings. Supports input lengths up to 8K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API
jina-embeddings-v4 Universal multimodal embeddings for text, image, and PDF retrieval. Accepts text, image, and PDF input and produces 2048-dimensional vector embeddings. Supports input lengths up to 32K tokens. Jina, Cloud Marketplaces, On-prem Jina API
jina-vlm Vision-language model for visual question answering. Accepts image and text input and generates text output. Supports input lengths up to 32K tokens. Jina, Cloud Marketplaces, On-prem Jina API
  • Use short video clips instead of long videos. Embeddings created from long videos are often less accurate for search because they try to represent too much content at once. Splitting videos into short clips or scenes improves retrieval quality.
  • Image, video, and audio inference is typically more expensive than text alone. Batch and chunk content to control latency and cost.
  • For long text fields: the model supports an input token length of 32K, but splitting very large passages into chunks often improves latency and per-chunk quality.
  • Use short video clips instead of long videos. Embeddings created from long videos are often less accurate for search because they try to represent too much content at once. Splitting videos into short clips or scenes improves retrieval quality.
  • Image, video, and audio inference is typically more expensive than text alone. Batch and chunk content to control latency and cost.
  • jina-embeddings-v5-omni-nano works best on small, medium or large sized fields that contain natural language. For connector or web crawler use cases, this aligns best with fields like title, description, summary, or abstract.
  • Although the model supports an input token length of 8K, consider chunking very large fields to control latency and cost.
  • Larger documents take longer at ingestion time, and inference time per document also increases the more fields in a document that need to be processed.
  • The more fields your pipeline has to perform inference on, the longer it takes per document to ingest.

Code embedding models convert source code and technical text into dense vectors for code search, technical Q&A, and repository retrieval.

Model Description Deployment Access
jina-code-embeddings-1.5b Code embeddings built on code generation models. Accepts source code and technical text and produces 1536-dimensional vector embeddings. Supports input lengths up to 32K tokens. Jina, Cloud Marketplaces, On-prem Jina API
jina-code-embeddings-0.5b Compact code embeddings for edge deployment. Accepts source code and technical text and produces 896-dimensional vector embeddings. Supports input lengths up to 32K tokens. Jina, Cloud Marketplaces, On-prem Jina API

Reader models extract clean, structured content from HTML and complex documents for indexing and RAG pipelines.

Model Description Deployment Access
ReaderLM-v2 Converts raw HTML into Markdown or JSON. Accepts HTML input and generates Markdown or JSON output. Supports input lengths up to 512K tokens. Jina, Cloud Marketplaces, On-prem Jina API

Reranker models reorder candidate documents by predicted relevance to improve top query results.

Model Description Deployment Access
jina-reranker-v3 Listwise reranker for multilingual document retrieval. Accepts text queries and documents and returns relevance rankings. Supports input lengths up to 131K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API
jina-reranker-m0 Multimodal reranker for visual documents. Accepts text or image queries and documents and returns relevance rankings. Supports input lengths up to 10K tokens. Jina, Cloud Marketplaces, On-prem Jina API
jina-reranker-v2-base-multilingual Cross-encoder reranker for multilingual search. Accepts text queries and documents and returns relevance rankings. Supports input lengths up to 1K tokens. Elastic Hosted, Elastic Serverless, Jina, Cloud Marketplaces, On-prem EIS, Jina API
jina-colbert-v2 Multilingual ColBERT model for embedding and reranking. Accepts text input and produces 128-dimensional multi-vector embeddings. Supports input lengths up to 8K tokens. Jina, Cloud Marketplaces, On-prem Jina API
  • jina-reranker-v3 is designed for top-k reranking in hybrid search and RAG workflows.
  • For larger candidate sets, rerank the most relevant results returned by your first-stage retrieval.
  • jina-reranker-v2-base-multilingual works best on small, medium or large sized fields that contain natural language. This aligns best with fields like title, description, summary, or abstract.
  • The model supports an input token length of 1K and automatically chunks larger content.
  • Larger documents take longer to process, and inference time also increases the more documents are present in the reranking request.

You can deploy Jina models in the following environments.

Models run on Elastic infrastructure. Access them through Elastic Inference Service (EIS).

Models run on the hosted Jina AI platform. Access them through the Jina API: with a direct API call, through External inference in Elasticsearch, or on-prem.

Selected models are available on providers such as AWS, Azure, and Google Cloud. After you deploy a model in your cloud account, you call the provider endpoint. For details, refer to Cloud marketplace endpoints.

Models run in Docker containers on your own infrastructure. Access them through the Jina API, including from Elasticsearch inference endpoints where supported.

You can access models in the following ways:

With Elastic Inference Service (EIS), Elastic hosts Jina models on Elastic Hosted and Elastic Serverless and serves them through managed inference endpoints in your cluster. Use this option when you want GPU-accelerated inference without deploying or managing model infrastructure.

To use a model through EIS, create an inference endpoint with "service": "elastic" and set model_id to the name of the model you want to use.

Text embedding models

The following examples use the text_embedding task type. Create an inference endpoint and reference the inference_id in text_embedding inference tasks or search queries:

				PUT _inference/text_embedding/eis-jina-embeddings-v5-text-small
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-embeddings-v5-text-small"
  }
}
		
				POST _inference/text_embedding/eis-jina-embeddings-v5-text-small
					{
  "input": "The sky above the port was the color of television tuned to a dead channel.",
  "input_type": "ingest"
}
		
				PUT _inference/text_embedding/eis-jina-embeddings-v5-text-nano
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-embeddings-v5-text-nano"
  }
}
		
				POST _inference/text_embedding/eis-jina-embeddings-v5-text-nano
					{
  "input": "The sky above the port was the color of television tuned to a dead channel.",
  "input_type": "ingest"
}
		
				PUT _inference/text_embedding/eis-jina-embeddings-v3
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-embeddings-v3"
  }
}
		
				POST _inference/text_embedding/eis-jina-embeddings-v3
					{
  "input": "The sky above the port was the color of television tuned to a dead channel.",
  "input_type": "ingest"
}

The following examples use the embedding task type.

Create an inference endpoint. The URL path uses the embedding task type and ends with the inference_id you want to use:

				PUT _inference/embedding/eis-jina-embeddings-v5-omni-small
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-embeddings-v5-omni-small"
  }
}
		
				PUT _inference/embedding/eis-jina-embeddings-v5-omni-nano
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-embeddings-v5-omni-nano"
  }
}
		
				PUT _inference/embedding/eis-jina-clip-v2
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-clip-v2"
  }
}

Reference the inference_id in embedding inference requests or search queries.

Below are examples of ingesting different types of content and generating vector embeddings using the inference_id created in the earlier request. The omni models support text, images, audio, video, and PDF documents. jina-clip-v2 supports text and image input only.

Text as a JSON array

Pass one or more plain text strings in the input array.

				POST _inference/embedding/eis-jina-embeddings-v5-omni-small
					{
  "input": [
    "A small blue square"
  ]
}
		
				POST _inference/embedding/eis-jina-embeddings-v5-omni-nano
					{
  "input": [
    "A small blue square"
  ]
}
		
				POST _inference/embedding/eis-jina-clip-v2
					{
  "input": [
    "A small blue square"
  ]
}
Text and image fused into one embedding

List both a text entry and a base64 image entry inside content so the model produces one embedding that represents the combined multimodal input.

				POST _inference/embedding/eis-jina-embeddings-v5-omni-small
					{
  "input": [
    {
      "content": [
        {
          "type": "text",
          "value": "A small blue square"
        },
        {
          "type": "image",
          "format": "base64",
          "value": "data:image/png;base64,<BASE64_IMAGE_DATA>"
        }
      ]
    }
  ]
}
		
				POST _inference/embedding/eis-jina-embeddings-v5-omni-nano
					{
  "input": [
    {
      "content": [
        {
          "type": "text",
          "value": "A small blue square"
        },
        {
          "type": "image",
          "format": "base64",
          "value": "data:image/png;base64,<BASE64_IMAGE_DATA>"
        }
      ]
    }
  ]
}

Use a single image block when the input contains only image data.

				POST _inference/embedding/eis-jina-embeddings-v5-omni-small
					{
  "input": [
    {
      "content": [
        {
          "type": "image",
          "format": "base64",
          "value": "data:image/png;base64,<BASE64_IMAGE_DATA>"
        }
      ]
    }
  ]
}
		
				POST _inference/embedding/eis-jina-embeddings-v5-omni-nano
					{
  "input": [
    {
      "content": [
        {
          "type": "image",
          "format": "base64",
          "value": "data:image/png;base64,<BASE64_IMAGE_DATA>"
        }
      ]
    }
  ]
}
		
				POST _inference/embedding/eis-jina-clip-v2
					{
  "input": [
    {
      "content": [
        {
          "type": "image",
          "format": "base64",
          "value": "data:image/png;base64,<BASE64_IMAGE_DATA>"
        }
      ]
    }
  ]
}

Encode a short video clip as base64. Short video clips usually produce more accurate embeddings for search than creating a single embedding from a longer video.

				POST _inference/embedding/eis-jina-embeddings-v5-omni-small
					{
  "input": [
    {
      "content": [
        {
          "type": "video",
          "format": "base64",
          "value": "data:video/mp4;base64,<BASE64_VIDEO_DATA>"
        }
      ]
    }
  ]
}
		
				POST _inference/embedding/eis-jina-embeddings-v5-omni-nano
					{
  "input": [
    {
      "content": [
        {
          "type": "video",
          "format": "base64",
          "value": "data:video/mp4;base64,<BASE64_VIDEO_DATA>"
        }
      ]
    }
  ]
}

Use this pattern for speech, music, or other audio you have already read and base64-encoded.

				POST _inference/embedding/eis-jina-embeddings-v5-omni-small
					{
  "input": [
    {
      "content": [
        {
          "type": "audio",
          "format": "base64",
          "value": "data:audio/wav;base64,<BASE64_AUDIO_DATA>"
        }
      ]
    }
  ]
}
		
				POST _inference/embedding/eis-jina-embeddings-v5-omni-nano
					{
  "input": [
    {
      "content": [
        {
          "type": "audio",
          "format": "base64",
          "value": "data:audio/wav;base64,<BASE64_AUDIO_DATA>"
        }
      ]
    }
  ]
}

Use the document block with base64-encoded files, such as PDFs, to create document embeddings.

				POST _inference/embedding/eis-jina-embeddings-v5-omni-small
					{
  "input": [
    {
      "content": [
        {
          "type": "pdf",
          "format": "base64",
          "value": "data:application/pdf;base64,<BASE64_PDF_DATA>"
        }
      ]
    }
  ]
}
		
				POST _inference/embedding/eis-jina-embeddings-v5-omni-nano
					{
  "input": [
    {
      "content": [
        {
          "type": "pdf",
          "format": "base64",
          "value": "data:application/pdf;base64,<BASE64_PDF_DATA>"
        }
      ]
    }
  ]
}

You can create another endpoint with a smaller dimensions value if you want shorter vectors from the same model. Smaller vectors, such as 32 dimensions, can reduce storage usage and improve search speed.

				PUT _inference/embedding/jina-omni-small-32d
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-embeddings-v5-omni-small",
    "dimensions": 32
  }
}
		
				PUT _inference/embedding/jina-omni-nano-32d
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-embeddings-v5-omni-nano",
    "dimensions": 32
  }
}
Note

The Jina v5 omni models availability and the support for the semantic_text field type depend on your Elastic Stack version:

  • In Elastic Stack 9.3 and later, you can create endpoints and run multimodal embedding inference requests. You cannot use these models with the semantic_text field type.
  • In Elastic Stack 9.4 and later, you can use semantic_text mappings for text-only embeddings at ingest and search time.
  • In Elastic Stack 9.5 and later, the semantic_field field type supports all modalities, such as text, images, video, audio, and documents.

The following examples use the rerank task type. Create an inference endpoint and reference the inference_id in rerank inference tasks:

				PUT _inference/rerank/eis-jina-reranker-v3
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-reranker-v3"
  }
}
		
				POST _inference/rerank/eis-jina-reranker-v3
					{
  "input": ["The Swiss Alps", "a steep hill", "a pebble", "a glacier"],
  "query": "mountain range"
}
		
				PUT _inference/rerank/jina-reranker-v2-base-multilingual
					{
  "service": "elastic",
  "service_settings": {
    "model_id": "jina-reranker-v2-base-multilingual"
  }
}
		
				POST _inference/rerank/jina-reranker-v2-base-multilingual
					{
  "input": ["luke", "like", "leia", "chewy", "r2d2", "star", "wars"],
  "query": "star wars main character"
}

You can use the Jina API in the following ways:

  • Jina API (hosted): Call models hosted on the Jina AI platform
  • On-prem: Run models on your own infrastructure, then call the Jina API schemas exposed locally.

When models run on the Jina AI platform, you call them through the hosted Jina API. To create a Jina AI API key, refer to Get your Jina API key.

Call the hosted Jina API with an HTTP request. The following example uses curl to send a rerank request for jina-colbert-v2:

curl https://api.jina.ai/v1/rerank \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <api_key>" \
  -d '{
    "model": "jina-colbert-v2",
    "query": "star wars main character",
    "documents": ["luke", "like", "leia", "chewy", "r2d2", "star", "wars"]
  }'

Connect Elasticsearch to the hosted Jina API through inference endpoints. Refer to External inference.

To use a hosted model from Elasticsearch, create an inference endpoint with "service": "jinaai" and set model_id to the name of the model you want to use.

The following example creates a rerank endpoint for jina-colbert-v2:

				PUT _inference/rerank/jina-colbert-v2-external
					{
  "service": "jinaai",
  "service_settings": {
    "api_key": "<api_key>",
    "model_id": "jina-colbert-v2"
  }
}
  1. Your Jina AI API key.
  2. The model to use for the inference task.

You can reference the inference_id of this endpoint in search queries.

For more information about creating Jina AI inference endpoints, including text_embedding, embedding and rerank task types, refer to the create a JinaAI inference endpoint API documentation.

With Jina on-prem, you run Jina models in Docker containers on your own infrastructure and access them through the Jina API schemas exposed by the container. Use this option when data cannot leave your network, when inference must work without outbound connectivity, or when compliance and data residency require self-hosted model deployment.

To pull, transfer, and run a prebuilt Docker image, refer to the Jina on-prem Quick Start.

For supported embedding and rerank models, you can connect Elasticsearch to the local server through inference endpoints that call the APIs exposed by the container. For the models that support this Elasticsearch integration today, refer to the model overview tables.

For an embedding model, create a text_embedding endpoint:

				PUT _inference/text_embedding/jina-embed
					{
  "service": "openai",
  "service_settings": {
    "url": "http://embed-host:8080/v1/embeddings",
    "model_id": "jina-embeddings-v5-text-small",
    "api_key": "not-needed"
  }
}
  1. Use the openai service type so Elasticsearch sends OpenAI-compatible text_embedding requests.
  2. Point url to the /v1/embeddings endpoint on your Jina on-prem host.
  3. Set model_id to the embedding model running in the container.
  4. This field is required by the Elasticsearch inference API but is not used by Jina on-prem. Specify any placeholder string, such as not-needed.

For a reranker model, create a rerank endpoint:

				PUT _inference/rerank/jina-rerank
					{
  "service": "cohere",
  "service_settings": {
    "url": "http://rerank-host:8081/v1/rerank",
    "model_id": "jina-reranker-v3",
    "api_key": "not-needed"
  }
}
  1. Use the cohere service type so Elasticsearch sends Cohere-compatible rerank requests. Jina on-prem exposes this schema locally. Requests do not go to Cohere.
  2. Point url to the /v1/rerank endpoint on your Jina on-prem host.
  3. Set model_id to the reranker model running in the container.
  4. This field is required by the Elasticsearch inference API but is not used by Jina on-prem. Specify any placeholder string, such as not-needed.

You can reference the inference_id of these endpoints in index mappings for the semantic_text field type, inference processors, or search queries.

You can also call any model running in a Jina on-prem container directly from your application or preprocessing pipeline through the Jina API, without creating an Elasticsearch inference endpoint. For request formats and supported API schemas, refer to the Jina on-prem API reference.

Note

Some models, like ReaderLM-v2 and jina-vlm, do not yet have a native Elasticsearch inference integration. For those models, call the Jina API exposed by the on-prem container, then send the results to Elasticsearch for indexing or search.

When you deploy a model from a cloud marketplace, the model runs in your cloud provider account. You access it by sending HTTP requests to the endpoint created in that environment, for example an Amazon SageMaker, Azure, or Google Cloud endpoint.

The request URL and payload format depend on the provider and listing. For current marketplace listings and provider-specific setup guidance, refer to the Jina model catalog.

Jina models are Elastic models available under a commercial license. How you are charged depends on where you deploy models and how you access them.

  • Models accessed through EIS on Elastic Hosted or Elastic Serverless are billed per million tokens, or as otherwise included in EIS. For details, refer to Pricing and the Elasticsearch Serverless pricing page. To use Jina models on EIS, you must have the appropriate subscription level or the trial period activated.
  • Models accessed through the hosted Jina API are billed according to your Jina AI account and API usage. Refer to Get your Jina API key.
  • For Jina on-prem and other commercial licensing, contact Elastic sales for pricing and licensing.

For more background and related resources:

  • jina-embeddings-v5-text: Introduces the compact multilingual text embedding models (small and nano) and how to use them on EIS.
  • jina-embeddings-v5-omni: Explains how to embed text, images, video, and audio into a single Elasticsearch index.
  • Jina rerankers on EIS: Covers jina-reranker-v2-base-multilingual and jina-reranker-v3 for multilingual reranking in retrieval and RAG workflows.
  • jina-embeddings-v3 on EIS: Introduces multilingual dense retrieval with jina-embeddings-v3 on EIS.
  • Jina model catalog: Browse the full set of Jina Search Foundation models and their capabilities.