pplx-embed-v2-context-9b

pplx-embed-v2-context-9b

Turns text, images and document pages into vectors for search, and can embed each chunk with its surrounding document in view. For developers who build retrieval over long documents.

Made by perplexity-ai on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: pplx-embed-v2-context-9b is an embedding model from perplexity-ai for search over text, images and document pages. In contextual mode it embeds each chunk of a document while seeing the text around it. In non-contextual mode each text input is embedded on its own.

Who it suits: Developers who build search over long documents, including page scans, and want vectors they can drop into a standard nearest-neighbor index.

Industry | Who uses it | How they use it | Example
Software | Search engineers | Embed document chunks and queries for dense retrieval | Index product docs and find the chunk that answers a question
Research | Retrieval researchers | Compare contextual and non-contextual embeddings | Embed the same chunks both ways and score one query
Document-heavy teams | Developers with scanned pages | Embed page images and match them to text queries | Look up the page that fits a written question

Anyone who needs a chat model or text generation can skip it, because it only produces embeddings.

Where to use it:

• Python with transformers: the model loads through AutoModel with its custom code.
• A CUDA GPU: the source's example moves the model to cuda.
• A dense nearest-neighbor index: chunked images can be retrieved through a standard one.
• Windows, macOS or Linux: the download steps run on all three with Python.

Use case | Who | What they get back
Document search | Search developers | One vector per chunk, scored against a query vector
Page image search | Developers with scanned pages | Embeddings of page images you can match to text queries
Mixed model setups | Teams already using the 0.6B model | Documents embedded with one model and queried with the other at 1024 dimensions

How to set it up: What you need first:

• Python with pip.
• transformers 5.4.0 or newer, plus torch, numpy, safetensors, tqdm, Pillow and torchvision.
• Optional: flash-linear-attention and causal-conv1d, which speed up the linear attention layers.
• A CUDA GPU if you follow the example, which moves the model to cuda.

1. Install the Hugging Face hub package with pip.
2. Download the model files with the hf command.
3. Install the requirements listed above.
4. Load the model with AutoModel and trust_remote_code set to True, because it uses custom code.

pip install -U huggingface_hub
hf download perplexity-ai/pplx-embed-v2-context-9b

How to use it: Pass each document as a list of chunks to encode, and pass queries to encode_queries. In contextual mode the chunks should not overlap. Encoding a query with encode lowers retrieval quality without any error. The vectors are not normalized as they come out. Either measure cosine similarity, or set normalize_embeddings to True and multiply the vectors as a dot product.

from transformers import AutoModel

model = AutoModel.from_pretrained(
    "perplexity-ai/pplx-embed-v2-context-9b",
    trust_remote_code=True,
).to("cuda")

# Two documents, consisting of several chunks
documents = [
    [
        "Curiosity begins in childhood with endless questions about the world.",
        "As we grow, curiosity drives us to explore new ideas.",
        "Scientific breakthroughs often start with a curious question.",
    ],
    [
        "The curiosity rover explores Mars searching for ancient life.",
        "Each discovery on Mars sparks new questions about the universe.",
    ],
]

# Contextual mode
# One (chunk_count, 2048) array per document:
# chunk_embeddings[0].shape == (3, 2048), chunk_embeddings[1].shape == (2, 2048)
chunk_embeddings = model.encode(documents, normalize_embeddings=True)

# Each query is a single-chunk row.
queries = [["What drives scientific breakthroughs?"]]
query_embeddings = model.encode_queries(queries, normalize_embeddings=True)

scores = chunk_embeddings[0] @ query_embeddings[0][0]

Title: Calls and options the source names
Tool | What it does
encode | Embeds document chunks, one array of vectors per document
encode_queries | Embeds queries, each one a single-chunk row
encode_images | Embeds page images as contextual chunks, one embedding per horizontal band
batch_size | Sets how many documents or queries go through in one pass, 32 by default

Example: You embed two documents as lists of chunks, one about curiosity and science and one about a Mars rover. Then you encode the query "What drives scientific breakthroughs?" and take the dot product with the first document's chunk vectors. You get one score per chunk, and you read the highest.

For newcomers and experts: An embedding model turns text or an image into a list of numbers, so that things with similar meaning end up close together. A good first try is to embed a few short chunks and one question, then see which chunk scores highest.

Training targeted two vector sizes, 1024 and 2048, using a Matryoshka-style loss. To get 1024 dimensions, keep the leading 1024 numbers of each raw vector, then normalize the shortened vector. Other truncation sizes were not trained. The text API does not truncate inputs, so you split long documents yourself.

Split each document into chunks that do not overlap
Encode the chunks with encode
Encode each query with encode_queries
Compare by cosine similarity or dot product

Good to know:

• Size: 8.4B parameters, and the F32 weights take about 33.6 GB.
• Dimensions: 2048 by default. The 1024 prefix shares a space with the 0.6B context model.
• Output: natively unnormalized int8-quantized embeddings.
• License: mit
• Cost to run: no API key, account or paid service named, but the example needs a CUDA GPU.
• Data it reaches: files you download from Hugging Face, and the text and images you embed. Custom code runs when trust_remote_code is on.
• Not for: text generation, overlapping chunks in contextual mode, or encoding queries with encode.

On Hugging Face, 13 November 2026

• Task: feature extraction
• Library: transformers
• Parameters: 8.4B
• Weights: about 33.6 GB in F32; about 4.2 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 766
• Likes: 16
• License: mit
• Based on: perplexity-ai/pplx-embed-v2-late-9b
• Tags: transformers, safetensors, pplx_contextual_qwen3_5, feature-extraction, sentence-similarity, contextual-embeddings, multilingual

Links

• Model: https://huggingface.co/perplexity-ai/pplx-embed-v2-context-9b
• Files: https://huggingface.co/perplexity-ai/pplx-embed-v2-context-9b/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download perplexity-ai/pplx-embed-v2-context-9b

Then follow the usage in its model card. Nothing in this kit runs by itself.