Guide

pplx-embed-v2-late: Plan PDF Retrieval and Index Storage

Use the current provider contract and worked examples to prepare a reviewable decision. Build a saved review workbench with Atoms.

Start building for free
7 min readPublished
pplx-embed-v2-late title above connected page cards, layered documents and a search field.
On this page

pplx-embed-v2-late is useful to evaluate when a PDF's layout, charts or tables carry meaning that a plain text passage can lose. It produces token-level vectors for late-interaction retrieval, so an adoption decision needs an index-storage budget and a page-level retrieval test alongside the model choice.

Perplexity offers 0.6B and 9B models in a shared embedding space. That supports a larger-model document index queried by the smaller model. This guide explains that deployment choice and provides executed synthetic MaxSim and storage calculations. It does not report a run of either embedding model.

Choose the retrieval problem before the model size

Start with a question that has a known relevant page. In a financial report, “What was the operating margin for the European segment?” may depend on the row label, column heading and unit being visible together. A passage containing only the number is insufficient even when a language model can produce a fluent answer.

Build a small evaluation set from the actual document family: annual reports, technical manuals or scanned forms. Include questions answered in running text, tables and charts, plus questions the corpus cannot answer. Record the relevant document and page before inspecting retrieval outputs. A retrieval system should return evidence you can open and verify.

Keep document version and page identity stable. If a PDF changes, page numbers can shift. Store a document checksum, page number and source URL with each indexed page. This lets a reviewer trace an answer back to the same source version instead of opening a newer file with different contents.

Understand what the models actually return

The official model card describes one 128-dimensional vector per token and MaxSim scoring. The two sizes share an embedding space, and the native Sentence Transformers path supports separate text-only and image-only encoding batches. Mixed text-plus-image input in one encoding batch is not supported by that documented path.

Configuration Index model Query model Decision to validate
Small throughout 0.6B 0.6B Does it meet page recall at the available cost?
Large throughout 9B 9B Does query-time quality justify the resources?
Asymmetric 9B 0.6B Does smaller query serving retain enough retrieval quality?

Perplexity's October 7 release describes the asymmetric setup as a deployment path where indexing is amortized and query embedding lies on the latency-critical path. That is a design rationale. Measure it on your corpus before claiming a latency or accuracy improvement.

The model card currently requires sentence-transformers >= 6.0.0 and transformers >= 5.4.0. Pin the model revision and dependency versions for the evaluation. Rebuilding the index under a different representation should be an explicit version change, not a silent update beneath existing results.

Work through MaxSim with a transparent example

MaxSim compares each query vector with the document vectors, takes its best match and sums those best matches. A single document vector is therefore not an equivalent replacement for the token-vector set.

This synthetic example uses two-dimensional unit vectors so the calculation is visible. The real model's documented width is 128 dimensions; these vectors are invented for arithmetic, not model output.

python
def dot(a, b):
    if len(a) != len(b):
        raise ValueError("dimension mismatch")
    return sum(x * y for x, y in zip(a, b))

def maxsim(query, document):
    if not query or not document:
        raise ValueError("nonempty vectors required")
    return sum(max(dot(q, d) for d in document) for q in query)

query = [[1.0, 0.0], [0.0, 1.0]]
page_a = [[1.0, 0.0], [0.0, 1.0]]
page_b = [[1.0, 0.0]]
assert maxsim(query, page_a) == 2.0
assert maxsim(query, page_b) == 1.0
print("synthetic MaxSim checks passed")

The checks were executed locally. Page A contains a match for both query directions; page B contains a match for only one. The result illustrates the score operation. It does not show how the embedding models represent actual words, images or pages.

Do not label a MaxSim score as a probability of relevance. It is a ranking score in the selected representation. Evaluate the ranked pages against known relevance labels, and compare scores only under a consistent model, preprocessing and scoring setup.

Calculate the raw vector-storage budget

Multi-vector storage depends on the number of vectors produced, their width and their stored numeric type. Use the counts observed from your own rendered pages. A page's dimensions and content can change the vector count, so a single average should be accompanied by its range.

For a synthetic planning example, assume 1,000 vectors per page, 128 dimensions, four bytes per value and 10,000 pages. Raw vector bytes are:

1,000 × 128 × 4 × 10,000 = 5,120,000,000 bytes

That is 5.12 decimal GB, about 4.77 GiB. It excludes the PDF files, rendered images, index structures, metadata, replicas and backups. Those missing components are part of the deployment budget; the raw calculation is only the vector array.

At two bytes per value, the same synthetic array is 2.56 GB. That arithmetic does not prove the database accepts that type or preserves retrieval quality. If you compress or quantize vectors, measure page recall and answer evidence after the change, and record the index format in the run manifest.

A useful storage worksheet includes page count, measured vectors per page, vector width, bytes per value, raw bytes, actual index size and retained replicas. Save the document and index versions together. This prevents a change in rendering settings from making last month's storage estimate appear current.

Compare page-image and text retrieval fairly

A fair comparison starts from the same source documents, questions and relevant-page labels. Keep the OCR or text extraction path visible. If the text baseline loses table headings during extraction, that is a property of the complete baseline pipeline, not proof that every text embedding is weaker.

Render PDF pages consistently for the image path. Record renderer, dimensions and image format. For the text path, preserve extraction settings and chunk boundaries. Return the same number of candidates from each system and judge against the same labels.

Report page recall separately from answer correctness. A retriever can find the right page while an answer generator misreads its unit. Conversely, a plausible answer can be generated from an irrelevant page. Keep the retrieved page, highlighted evidence and final answer together so reviewers can inspect the connection.

Include absent-answer questions. The application should allow a reviewer to say the corpus does not contain the requested fact. Forcing an answer for every question hides the boundary between retrieval and invention.

Check managed API availability independently

Published weights and a planned API rollout are different release states. Perplexity's October 7 post says support for late-interaction, dense and contextual embeddings will roll out progressively. This guide does not establish an active managed v2-late endpoint or per-token rate.

Before budgeting a managed route, check the exact model catalog, endpoint, modality, output shape and current price. A price for a dense or contextual v1 embedding model cannot be treated as a v2-late quote. For self-hosting, collect GPU time, indexing time, query capacity and index storage from the run you actually operate.

The lowest-cost first check can be an offline evaluation over an approved document sample. Establish that page retrieval helps the task before building a larger production index. Then expand the corpus under the same acceptance conditions and measure the new resource profile.

Build a PDF retrieval review application with Atoms

Use Atoms to make a review interface for questions, ranked pages and evidence. Start with imported retrieval results and document links. An embedding service and vector database require separate integration; the application brief does not establish native pplx-embed support.

Ask for document checksum, page ID, query ID, model revision, index version, retrieved rank, relevance label and reviewer note. Show a page preview beside the question and make the evidence location inspectable. Compute recall from labeled questions, excluding unlabeled records rather than treating them as failures or successes.

In the preview, use invented records with a known relevant page and check the ranking table. Save a reviewer correction, reload it and confirm that the original retrieval record remains intact. For persistent multi-user review, consult the Atoms Cloud guide and test document permissions before importing restricted PDFs.

Conclusion

Evaluate pplx-embed-v2-late on the pages your users need, price the complete multi-vector index, and keep retrieval evidence separate from generated answers. The asymmetric model setup is a useful option to test, not a measured result for your corpus. Build the PDF retrieval review application in Atoms to inspect the ranked evidence and retain the evaluation record.

A little more clarity

Frequently asked questions

01Q1: Can the 0.6B model query a 9B-built index?

The official model card documents a shared embedding space that supports that configuration. Verify its quality and query resources on the same labeled corpus.

02Q2: Can I mix text and page images in one encoding batch?

The documented native path requires separate text-only and image-only calls. Follow the current model-card contract when constructing batches.

03Q3: Is the raw 5.12 GB example a production index estimate?

It is a synthetic vector-array calculation. Actual index structures, source files, metadata, replicas and backups add storage.

04Q4: What was measured here?

Only synthetic MaxSim results and storage arithmetic were executed. Embedding quality, inference latency and production index size were not measured.

Share this article
Made with Atoms

Your next idea starts here.

Turn what you learned into a working app or website.

Start building for free