DeepSeek VL2: A Guide to the MoE Vision-Language Model Family

Need a vision-language model that reads receipts, parses charts and points at the giraffe at the back of the photo, and that you can run on your own hardware? DeepSeek VL2 is DeepSeek’s open-weight answer from December 2024: three Mixture-of-Experts (MoE) checkpoints on Hugging Face, from a Tiny model that DeepSeek says runs on a single GPU with under 40 GB up to a full model that needs more than 80 GB. This guide covers what’s inside the model, how the three variants compare, the DeepSeek-reported benchmark numbers, where it falls short, and the practical ways to deploy it today.

What DeepSeek VL2 actually is

DeepSeek VL2 is a series of open-weight vision-language models from DeepSeek-AI built on a Mixture-of-Experts backbone. According to its technical report (arXiv 2412.10302, submitted 13 December 2024), it improves on its predecessor, DeepSeek-VL, with two key upgrades: a dynamic tiling vision encoder for high-resolution images with different aspect ratios, and DeepSeekMoE language models, with Multi-head Latent Attention (MLA) in the Small and full models, which compresses the key-value cache into latent vectors for efficient inference. The result is a model family aimed at document OCR, chart and table parsing, multi-image conversation and visual grounding while activating only a fraction of its total parameters per token. The GitHub README dates the family’s release to 13 December 2024.

If you’ve used the earlier DeepSeek VL release, VL2 is the same lineage with a sparse backbone and a much stronger OCR pipeline. It predates DeepSeek’s current API models and is not served on the API; for hosted work, DeepSeek’s API today offers deepseek-flash and deepseek-v4-pro (see the DeepSeek V4 overview).

Architecture and lineage

The VL2 stack is deliberately modular. It adopts a LLaVA-style decoder-only structure that combines a vision encoder, a vision-language adaptor and an MoE language model. The vision encoder is a single SigLIP-SO400M-384 model that processes images with a dynamic tiling strategy: a high-resolution image is split into local 384×384 tiles plus one global thumbnail tile, to handle diverse aspect ratios while keeping computation in check. A 2×2 pixel shuffle compresses each tile from 729 to 196 visual tokens, and a two-layer MLP projects them into the language model’s embedding space.

On the language side, all three variants use DeepSeekMoE (64, 64 and 72 routed experts plus 2 shared, with 6 selected per token) but differ in scale. The report describes three MoE language models of 3B, 16B and 27B with 0.57B, 2.4B and 4.1B activated parameters respectively. The “1.0B / 2.8B / 4.5B activated” figures in the abstract and model cards include the vision encoder and adaptor. The Tiny model uses standard multi-head attention; Small and the full model use MLA.

Variant breakdown

Total sizes and GPU notes come from DeepSeek’s GitHub README; activated counts and base-LLM mapping from the paper and Hugging Face cards. The README’s demo comments describe vl2-tiny as 3.37B-MoE in total with 1B activated (runs on a single GPU under 40 GB), vl2-small as 16.1B in total with 2.4B activated, and the full vl2 as 27.5B in total with 4.2B activated; those activated figures mix conventions and differ slightly from the paper’s. The README also notes you may need 80 GB of GPU memory to run its demo script with deepseek-vl2-small, and more for deepseek-vl2. All three checkpoints have a 4,096-token sequence length.

One quirk worth knowing before you push it into a pipeline: to keep tokens manageable, dynamic tiling is applied only when there are two or fewer images. With three or more images, inputs are padded to 384×384 without tiling. Plan your batching accordingly; high-resolution multi-document prompts should be split across turns.

Benchmarks worth trusting

The numbers below come from Tables 3 and 4 of the VL2 technical report and are DeepSeek-reported. They compare DeepSeek-VL2 (4.5B activated) with other models at their reported sizes, and they reflect the multimodal field as it stood in December 2024.

On the OCR-related benchmarks, the full DeepSeek-VL2 scores 811 on OCRBench (the Small variant 834, the Tiny 809), against 736 for GPT-4o in the same table, and 93.3 on DocVQA against GPT-4o’s 92.8. On general multimodal benchmarks the picture is closer to its size class: 83.1 on MMBench against 83.0 for Qwen2-VL-7B (8.3B), 2,253 on MME against 2,327 for Qwen2-VL-7B, and 61.3 on MMStar against GPT-4o’s 63.9, with far fewer activated parameters. On MMMU it trails GPT-4o by a wide margin (51.1 vs 69.1).

Where DeepSeek VL2 specifically wins

• Document OCR and dense text. The OCRBench and DocVQA numbers above are its strongest results, which makes it a natural open-weight candidate for invoices, contracts, forms and scanned PDFs.
• Visual grounding. VL2 can localise objects in images from a description, and the README explains that adding the special <|grounding|> token at the start of a prompt enables grounded captioning, with object coordinates returned in the response. That is useful for UI-agent work.
• High-resolution flexibility. VL2 uses 384×384 tiling plus a global thumbnail, with up to 9 local tiles by default and up to 18 in the report’s InfoVQA evaluation for extreme aspect ratios. That handles tall receipts and wide spreadsheets without a custom preprocessing layer.
• Activation efficiency. Per-token compute scales with the 4.5B activated parameters of the full model, although all 27.5B parameters still have to be held in memory.
• Commercial use allowed. The code repository is licensed under MIT; use of DeepSeek-VL2 models is subject to the DeepSeek Model License, and DeepSeek states that the series supports commercial use.

Where it falls short

VL2 is a December 2024 model, and its own report lists the limits: a context window that “only allows for a few images per chat session”, occasional problems with blurry images or unseen objects, and reasoning that DeepSeek says it aims to strengthen. Specifically:

• No first-party API. DeepSeek’s hosted API (pricing page checked 26 October 2026) lists deepseek-flash (DeepSeek-V4.1-Flash-1017) and deepseek-v4-pro (DeepSeek-V4-Pro-0813), not VL2. Image input is supported on the API, but only through deepseek-flash; VL2 itself is open weights only.
• No video. The report covers single-image and multi-image input; there is no temporal (video) modelling.
• Reasoning ceiling. Its MMMU score (51.1) is far below GPT-4o’s 69.1 in the same table, and the report names stronger reasoning as future work.
• Hardware floor. DeepSeek-VL2-Small needs 40 GB even with incremental prefilling. Tiny is the only variant DeepSeek describes as running on a single GPU under 40 GB.
• Tiling limit on multi-image. The two-image dynamic tiling cap (above) and the 4,096-token sequence length are real ceilings for batch document workflows.

How to access DeepSeek VL2

There is no DeepSeek VL2 endpoint on the official API, so self-hosting is the path. Three practical options:

1. Hugging Face Transformers. Install the deepseek-ai/DeepSeek-VL2 GitHub package, pull deepseek-ai/deepseek-vl2-tiny, -small or deepseek-vl2 and load with trust_remote_code=True. On 26 October 2026 the current files total about 6.75 GB (Tiny), 32.30 GB (Small) and 54.97 GB (full). Suitable for prototyping and small-batch jobs.
2. Optimised serving stacks. DeepSeek’s README calls its own demo a basic implementation without deployment optimisations and suggests vLLM, SGLang or LMDeploy for production environments, for faster responses and better cost efficiency.
3. Cloud GPU rental. Per the README, the Small variant runs on an A100 40 GB with incremental prefilling (--chunk_size 512), and the full model needs more than 80 GB. See our DeepSeek hardware calculator to size it before you book.

Minimal Transformers load (Python)

The snippet below, following the README, loads VL2-Tiny in bfloat16. The model cards suggest a sampling temperature T ≤ 0.7, as higher temperatures decrease generation quality.

import torch
from transformers import AutoModelForCausalLM
from deepseek_vl2.models import DeepseekVLV2Processor, DeepseekVLV2ForCausalLM

model_path = "deepseek-ai/deepseek-vl2-tiny"
processor = DeepseekVLV2Processor.from_pretrained(model_path)
tokenizer = processor.tokenizer
model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True)
model = model.to(torch.bfloat16).cuda().eval()
# pass `conversation` (with role + image refs) through processor, then model.generate()

How VL2 fits next to DeepSeek’s current API

Many VL2 pipelines also need a text model behind the same product, to summarise extracted documents, answer follow-up questions or run agent loops. On DeepSeek’s API that role falls to the two current models, deepseek-flash (DeepSeek-V4.1-Flash-1017) and deepseek-v4-pro (DeepSeek-V4-Pro-0813). Both offer a 1M-token context, up to 384K output tokens and thinking mode on by default, and both publish open weights under MIT. deepseek-flash also accepts images, so for some document tasks it is a hosted alternative to self-hosting VL2 rather than just its text partner.

Chat requests go to POST /chat/completions on https://api.deepseek.com (OpenAI-compatible). The API is stateless, so clients must resend the conversation history with every request. For the full developer surface (models, parameters, JSON mode, tool calling, streaming, context caching), start with the DeepSeek API documentation.

Cost snapshot — deepseek-flash for the text leg of a VL2 pipeline

Self-hosted VL2 has no per-token fee; your cost is the GPU time. If you send VL2’s OCR output to deepseek-flash for downstream summarisation, the October 2026 rates per 1M tokens are $0.30 for cache-miss input and $1.20 for output at peak, and $0.15 and $0.60 off-peak (cache hits $0.006 peak / $0.003 off-peak). Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, excluding Chinese public holidays. deepseek-v4-pro costs 4.4× as much on cache-miss input and 3.3× on output. Verify on the DeepSeek API pricing page before committing.

Best use cases

• Document automation and back-office OCR: invoices, claims, KYC forms. See DeepSeek for business.
• Data extraction at scale: tables, charts, scanned reports. Pair with DeepSeek for data analysis.
• Developer tooling: UI screenshot understanding, GUI agents, visual grounding for web automation.
• Education and accessibility: describing images, parsing handwritten or printed material.

Comparable alternatives

If VL2’s reasoning ceiling or hardware floor is a problem, look at newer releases of the open VLM families DeepSeek compared against in its report (InternVL and Qwen-VL among them), and at the closed multimodal APIs from OpenAI, Anthropic and Google. If you want to stay with DeepSeek but drop self-hosting, deepseek-flash on DeepSeek’s API accepts images. For text-side comparisons, see DeepSeek vs Claude and DeepSeek vs ChatGPT. Other open-weight models are covered in the open-source AI like DeepSeek roundup, and you can browse the wider DeepSeek models hub for VL2’s siblings.

Verdict

DeepSeek VL2 remains a strong open-weight option for OCR-heavy and document-understanding workloads when you need control over where data goes, predictable cost and a licence that permits commercial use; its DeepSeek-reported OCRBench and DocVQA scores were ahead of GPT-4o’s at release. It is not the model to pick for video, deep multimodal reasoning or zero-ops deployment: it is a self-hosted model with a December 2024 ceiling.