Open Models Almanac
ModelsDeepSeek-V4-Pro

DeepSeek

DeepSeek-V4-Pro

What DeepSeek-V4-Pro’s own documents say it is built from — every method with the sentence that describes it.

Parameters
1.6T / 49B active
Context
1M
Attention
sparse (indexer)Compressed Sparse Attention + Heavily Compressed Attention with indexer, sliding window 128, attention sink
Experts
384 routed + 1 shared, top-6
Input
text
Licence
MIT
Released
2026-04-24

Against the consensus recipe

Its documents state 7 of the 18 methods the field agrees on.

The recipe from the overview: the methods the most labs adopt, per stage. A missing one is something its documents do not say, not something the model lacks.
  1. Data curation

  2. Training objective

  3. Model architecture

  4. Optimization

  5. Post-training

  6. Inference & serving

Checked in its code

Its code shows 11 of the 19 architecture features checked — 4 of them are not stated in its documents.

Sources say what a lab chose to describe; the modeling code says what the checkpoint runs. Each feature below was put to a code verifier, and only the config values and source lines it cited that were found in the files are shown, linked to the line.

Read from Hugging Face Transformers (modeling_deepseek_v4.py, configuration_deepseek_v4.py) and config.json at revision b5968e9190, by anthropic/claude-sonnet-5 on 2026-11-07.

FeatureCodeIts documentsVerdict
Grouped-query attention not in its codenot stated

num_key_value_heads=1 implements shared-KV multi-query attention, but the single KV vector is a low-rank-projected latent reused via…

show evidence

num_key_value_heads=1 implements shared-KV multi-query attention, but the single KV vector is a low-rank-projected latent reused via broadcasting rather than grouped multi-head KV projection, and the model otherwise relies on MLA-style projections, so GQA as a head-grouping mechanism with multiple real KV heads is not present (it's MQA/MLA-like with one shared KV head).

num_key_value_heads = 1num_attention_heads = 128
self.num_key_value_groups = config.num_attention_heads  # single KV head, broadcast to all
modeling_deepseek_v4.py · L790
Multi-head latent attention not in its codenot stated

There is no kv_lora_rank; keys/values are not down-projected into a shared low-rank latent and up-projected per head, instead a single…

show evidence

There is no kv_lora_rank; keys/values are not down-projected into a shared low-rank latent and up-projected per head, instead a single shared KV head (head_dim=512) is produced directly by kv_proj, so this is not DeepSeek-V2-style MLA.

q_lora_rank = 1536
self.kv_proj = nn.Linear(config.hidden_size, self.head_dim, bias=False)
        self.kv_norm = DeepseekV4RMSNorm(self.head_dim, eps=config.rms_norm_eps)
modeling_deepseek_v4.py · L801–802
Sliding-window attention in its codeadopted

Every attention layer (sliding_attention, CSA, HCA) uses a sliding-window cache of size config.sliding_window=128 as its base local K/V…

show evidence

Every attention layer (sliding_attention, CSA, HCA) uses a sliding-window cache of size config.sliding_window=128 as its base local K/V window.

sliding_window = 128
self.sliding_window = config.sliding_window
modeling_deepseek_v4.py · L792
Interleaved sliding-window and global attention code unclearnot stated

layer_types is derived at runtime from compress_ratios (ending with a 0 which maps to sliding_attention, others to…

show evidence

layer_types is derived at runtime from compress_ratios (ending with a 0 which maps to sliding_attention, others to compressed_sparse_attention/heavily_compressed_attention), but all layer types still apply the same sliding_window base cache, and compress-attention layers additionally concatenate long-range compressed KV rather than attending to the genuinely full context, so whether any layer is truly 'full-context' versus all being sliding-window-based cannot be settled from the given files.

sliding_window = 128
_COMPRESS_RATIO_TO_LAYER_TYPE = {
    0: "sliding_attention",
    4: "compressed_sparse_attention",
    128: "heavily_compressed_attention",
}
configuration_deepseek_v4.py · L28–32
Indexer-selected sparse attention (DeepSeek Sparse Attention) in its codeadopted

DeepseekV4Indexer scores compressed KV entries with index_n_heads/index_head_dim and keeps only the top index_topk=1024 entries per query…

show evidence

DeepseekV4Indexer scores compressed KV entries with index_n_heads/index_head_dim and keeps only the top index_topk=1024 entries per query for CSA layers.

index_topk = 1024index_n_heads = 64index_head_dim = 128
top_k_indices = index_scores.topk(top_k, dim=-1).indices  # [B, S, k]
            invalid = top_k_indices >= causal_threshold.unsqueeze(-1)
            return torch.where(invalid, torch.full_like(top_k_indices, -1), top_k_indices)
modeling_deepseek_v4.py · L593–595
Linear-attention or state-space layers alongside full attention not in its codenot stated

No linear-attention or state-space recurrent mixer layers exist; all layer_types (sliding_attention, compressed_sparse_attention…

show the whole verdict

No linear-attention or state-space recurrent mixer layers exist; all layer_types (sliding_attention, compressed_sparse_attention, heavily_compressed_attention) are softmax-attention variants implemented by DeepseekV4Attention.

Gated DeltaNet layers not in its codenot stated

There is no gated delta-rule recurrent state update implemented anywhere in this file; all token mixing is softmax attention.

Mamba-2 layers not in its codenot stated

No Mamba-2/SSD selective state-space block is implemented in this file.

Learnable attention sink code only in its codenot stated

Each attention layer has a per-head learnable sink parameter concatenated into the softmax denominator in eager_attention_forward.

show evidence
sinks = module.sinks.reshape(1, -1, 1, 1).expand(query.shape[0], -1, query.shape[-2], -1)
    combined_logits = torch.cat([attn_weights, sinks], dim=-1)
modeling_deepseek_v4.py · L744–745
self.sinks = nn.Parameter(torch.empty(self.num_heads))
modeling_deepseek_v4.py · L807
Gated attention output not in its codenot stated

The attention output is not multiplied by an input-dependent sigmoid gate; instead it undergoes a conjugate RoPE rotation and a grouped…

show evidence

The attention output is not multiplied by an input-dependent sigmoid gate; instead it undergoes a conjugate RoPE rotation and a grouped output projection, with no sigmoid gating mechanism present.

grouped = attn_output.reshape(*input_shape, self.config.o_groups, -1)
        grouped = self.o_a_proj(grouped).flatten(2)
        output = self.o_b_proj(grouped)
modeling_deepseek_v4.py · L881–883
QK normalization code only in its codenot stated

Queries are normalized with an unweighted RMSNorm per head (q_b_norm) before the attention dot product; keys (the shared KV) are…

show evidence

Queries are normalized with an unweighted RMSNorm per head (q_b_norm) before the attention dot product; keys (the shared KV) are normalized with kv_norm as well.

q = self.q_b_proj(q_residual).view(*hidden_shape).transpose(1, 2)
        q = self.q_b_norm(q)
        q = apply_rotary_pos_emb(q, cos, sin)
modeling_deepseek_v4.py · L828–830
kv = self.kv_norm(self.kv_proj(hidden_states)).view(*hidden_shape).transpose(1, 2)
modeling_deepseek_v4.py · L832
Partial RoPE code only in its codenot stated

RoPE is applied only to the trailing qk_rope_head_dim=64 of each 512-dim head (partial_rotary_factor=64/512), leaving the rest of the head…

show evidence

RoPE is applied only to the trailing qk_rope_head_dim=64 of each 512-dim head (partial_rotary_factor=64/512), leaving the rest of the head dimension without position signal.

qk_rope_head_dim = 64head_dim = 512
rope_dim = cos.shape[-1]
    nope, rope = x[..., :-rope_dim], x[..., -rope_dim:]
    rotated = ((rope.float() * cos) + (rotate_half(rope).float() * sin)).to(x.dtype)
    return torch.cat([nope, rotated], dim=-1)
modeling_deepseek_v4.py · L367–370
YaRN RoPE scaling code only in its codenot stated

rope_scaling.type is yarn and is wired into the compress rope-type parameters that the YaRN-capable ROPE_INIT_FUNCTIONS dispatch consumes…

show evidence

rope_scaling.type is yarn and is wired into the compress rope-type parameters that the YaRN-capable ROPE_INIT_FUNCTIONS dispatch consumes for compressed-attention layers.

rope_scaling = {"beta_fast": 32, "beta_slow": 1, "factor": 16, "original_max_position_embedd…
rope_init_fn = self.compute_default_rope_parameters
            if self.rope_type[layer_type] != "default":
                rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type[layer_type]]
modeling_deepseek_v4.py · L104–106
Layers without positional encoding (NoPE) not in its codenot stated

All attention layers apply partial RoPE (either 'main' or 'compress' rope type) to their rope slice; there is no attention layer that…

show evidence

All attention layers apply partial RoPE (either 'main' or 'compress' rope type) to their rope slice; there is no attention layer that skips positional encoding entirely.

self.rope_layer_type = "main" if self.layer_type == "sliding_attention" else "compress"
modeling_deepseek_v4.py · L788
Mixture of experts in its codeadopted

Feed-forward layers route tokens to n_routed_experts=384 expert MLPs via a learned TopKRouter/HashRouter selecting num_experts_per_tok=6…

show evidence

Feed-forward layers route tokens to n_routed_experts=384 expert MLPs via a learned TopKRouter/HashRouter selecting num_experts_per_tok=6 experts.

n_routed_experts = 384num_experts_per_tok = 6
indices = torch.topk(scores + self.e_score_correction_bias, self.top_k, dim=-1, sorted=False).indices
modeling_deepseek_v4.py · L1094
Shared expert in its codeadopted

Every MoE layer adds one shared DeepseekV4MLP expert that all tokens pass through, with n_shared_experts=1.

show evidencen_shared_experts = 1
routed = self.experts(flat, indices, weights).view(batch, seq_len, hidden_dim)
        return routed + self.shared_experts(residual)
modeling_deepseek_v4.py · L1147–1148
Auxiliary-loss-free load balancing (selection bias) in its codeadopted

The router adds e_score_correction_bias to scores only for top-k selection (not for the weights used to scale expert outputs), matching…

show evidence

The router adds e_score_correction_bias to scores only for top-k selection (not for the weights used to scale expert outputs), matching DeepSeek-V3's bias-based auxiliary-loss-free balancing, enabled via topk_method noaux_tc.

topk_method = "noaux_tc"
indices = torch.topk(scores + self.e_score_correction_bias, self.top_k, dim=-1, sorted=False).indices
        weights = scores.gather(1, indices)
modeling_deepseek_v4.py · L1094–1095
Multi-token prediction layers in its codeadopted

The config declares num_nextn_predict_layers=1 (MTP module count), and the modeling file's ignore-on-load pattern for 'mtp.' prefixed keys…

show evidence

The config declares num_nextn_predict_layers=1 (MTP module count), and the modeling file's ignore-on-load pattern for 'mtp.' prefixed keys confirms the checkpoint carries these extra modules even though they are not built in this file.

num_nextn_predict_layers = 1
_keys_to_ignore_on_load_unexpected = [r"(^|\.)mtp\..*"]
modeling_deepseek_v4.py · L1266
SwiGLU feed-forward in its codeadopted

Both the dense DeepseekV4MLP and the MoE DeepseekV4Experts compute act_fn(gate)*up with hidden_act=silu, i.e. SwiGLU.

show evidencehidden_act = "silu"
gate = self.gate_proj(x).clamp(max=self.limit)
        up = self.up_proj(x).clamp(min=-self.limit, max=self.limit)
        return self.down_proj(self.act_fn(gate) * up)
modeling_deepseek_v4.py · L1033–1035

token mixer 9

softmax attention 3

sliding window attention 1

Sliding Window Attention used

“we introduce a supplementary attention branch to both CSA and HCA in a sliding window manner”

grouped-query attention 1

Multi-query attention used

“CSA then performs core attention in a Multi-Query Attention (MQA) manner”

attention sink 1

Attention sink used

“we employ the trick of attention sink”

sparse attention 5

DeepSeek Sparse Attention core

“Novel Attention: Token-wise compression + DSA (DeepSeek Sparse Attention)”

Compressed Sparse Attention core

“we design a hybrid attention mechanism combining Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA)”

Heavily Compressed Attention core

“we design a hybrid attention mechanism combining Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA)”

Token-wise compression core

“Novel Attention: Token-wise compression + DSA (DeepSeek Sparse Attention)”

Two-stage sparse-attention training used

“the strategy of introducing sparse attention is the same as DeepSeek-V4-Flash, following a two-stage training method.”

hybrid layer stacking 1

Hybrid compressed attention (CSA and HCA) used

“Hybrid Attention Architecture: We design a hybrid attention mechanism combining Compressed Sparse Attention (CSA) and Heavily Compressed…”

channel mixer 10

dense feed-forward network 2

SwiGLU used

“each token-expert pair requires FLOPs (SwiGLU gate, up, and down projections)”

SwiGLU clamping used

“applying SwiGLU clamping effectively eliminates outliers and substantially aids in stabilizing the training process”

mixture of experts 8

Mixture of experts core

“two strong Mixture-of-Experts (MoE) language models — DeepSeek-V4-Pro with 1.6T parameters (49B activated) and DeepSeek-V4-Flash with 284B…”

DeepSeekMoE core

“DeepSeek-V4 series retain the DeepSeekMoE framework”

MegaMoE used

“We have open-sourced the CUDA-based mega-kernel implementation named MegaMoE”

expert routing 3

Anticipatory Routing used

“Anticipatory Routing (computing routing indices one step ahead to decouple backbone and routing updates)”

Hash routing used

“we replace the dense FFN layers in the initial several Transformer blocks with MoE layers that employ Hash routing”

Loss-spike-triggered Anticipatory Routing optional

“we introduced an automatic detection mechanism that triggers a short rollback and activates Anticipatory Routing exclusively when a loss…”

expert load balancing 1

Auxiliary-loss-free load balancing used

“For auxiliary-loss-free load balancing, we set the bias update speed to 0.001.”

shared experts 1

Shared expert core

“sets fine-grained routed experts and shared experts”

positional encoding 1

Rotary Position Embedding used

“we partially employ the Rotary Positional Embedding (RoPE) to the attention queries, KV entries, and the core attention outputs”

normalization & residual 2

Manifold-Constrained Hyper-Connections core

“DeepSeek-V4 series incorporate Manifold-Constrained Hyper-Connections (mHC) to strengthen the conventional residual connections”

RMSNorm used

“we perform an additional RMSNorm operation on each head of the queries and the only head of the compressed KV entries”

prediction head 1

Multi-Token Prediction core

“DeepSeek-V4 series also set MTP modules and objectives”

context capacity 1

1M-token context window default

“1M context is now the default across all official DeepSeek services”

Not used 2

QK-Clip not used

normalization & residual “we do not employ the QK-Clip technique”

Engram not used

context capacity “Engram conditional memory is absent from V4”

distillation objective 1

Full-vocabulary logit distillation used

“we adopt full-vocabulary logit distillation in our OPD.”

auxiliary loss 1

Sample-level attention masking used

“we employ sample-level attention masking during pre-training.”

optimizer 4

Muon core

“We employ the Muon optimizer for the majority of modules in DeepSeek-V4 series”

AdamW used

“We maintain the AdamW optimizer for the embedding module, the prediction head module, the static biases and gating factors of mHC modules…”

Nesterov momentum used

“we also apply weight decay to Muon parameters, use the Nesterov trick”

Hybrid Newton–Schulz iterations used

“we use hybrid Newton-Schulz iterations for orthogonalization”

learning-rate schedule 1

Batch-size warmup used

“we also employ a batch size scheduling strategy that increases the batch size (in tokens) from a small size to 75.5M”

training precision 1

FP4 and FP8 mixed precision used

“FP4 + FP8 Mixed: MoE expert parameters use FP4 precision; most other parameters use FP8.”

quantization-aware training 4

Quantization-Aware Training used

“we introduce Quantization-Aware Training (QAT) [QAT] during the post-training stage”

MXFP4 Quantization-Aware Training used

“we incorporate FP4 quantization-aware training for MoE expert weights and the indexer QK path”

FP4 Quantization used

“We apply FP4 (MXFP4) quantization [OCP_MXFormat] to two components”

Straight-Through Estimator used

“equivalent to applying the Straight-Through Estimator (STE) through the quantization operation”

training parallelism 4

All-to-all gradient exchange with local FP32 summation used

“First, an all-to-all operation exchanges local gradients across ranks, and then each rank performs a local sum in FP32.”

Hybrid ZeRO bucket assignment for Muon used

“To address this conflict, we design a hybrid strategy of ZeRO bucket assignment for Muon.”

Knapsack-based balanced assignment of dense parameter matrices used

“we employ a knapsack algorithm to assign parameter matrices to these ranks, ensuring each rank manages a roughly balanced load.”

Modified DualPipe 1F1B pipeline overlap for mHC used

“we adjust the DualPipe 1F1B overlapping scheme to accommodate the increased pipeline communication”

training runtime 3

Tensor-level automatic-differentiation activation checkpointing core

“we implement a tensor-level activation checkpointing mechanism with automatic differentiation support.”

Minimal recomputation-graph extraction by backward graph traversal used

“For each annotated tensor, it performs a backward traversal to identify the minimal subgraph required for its recomputation.”

Selective tensor recomputation for activation-memory reduction used

“we introduce a recomputation strategy that selectively checkpoints intermediate tensors.”

filed at the root 1

Multilingual corpus expansion used

“V4 also expands its multilingual corpus”

data sourcing 1

Long-document curation used

“V4 places particular emphasis on scientific papers, technical reports”

data filtering 1

Filtering batched auto-generated and templated web content used

“we implement filtering strategies to remove batched auto-generated and templated content”

synthetic data 2

Rubric-guided RL data used

“DeepSeek curates rubric-guided RL data”

Task-specific data injection used

“DeepSeek incorporates agentic data during what it calls the 'mid-training phase'”

sequence packing 1

Cross-source document packing used

“we pack documents from different sources into appropriate sequences to minimize sample truncation.”

tokenization 1

Quick Instruction tokens used

“We append a set of dedicated special tokens directly to the input sequence, where each token corresponds to a specific auxiliary task.”

supervised fine-tuning 2

Supervised fine-tuning used

“independent cultivation of domain-specific experts (through SFT and RL with GRPO)”

Specialist training used

“DeepSeek trains independent specialist models — one for mathematics, one for coding, one for agent tasks, one for instruction following”

reinforcement learning algorithm 2

Reinforcement learning used

“followed by Reinforcement Learning using Group Relative Policy Optimization (GRPO)”

Group Relative Policy Optimization used

“For the RL stage, we implemented the Group Relative Policy Optimization (GRPO) algorithm”

reward modelling 2

Generative Reward Model used

“we curate rubric-guided RL data and employ a Generative Reward Model (GRM) to evaluate policy trajectories.”

Direct RL optimization of a generative reward model used

“Crucially, we apply RL optimization directly to the GRM itself.”

policy distillation 2

Multi-Teacher On-Policy Distillation core

“we employ multi-teacher On-Policy Distillation (OPD) as the primary technique for merging expert capabilities into the final model.”

On-Policy Distillation core

“post-training pipeline replaces reinforcement learning with On-Policy Distillation from 10+ domain specialists”

rollout & RL infrastructure 1

Preemptible rollout service with write-ahead logging used

“The preemptible rollout service preserves partial generations through a token-granular Write-Ahead Log.”

mid-training & continual pretraining 1

Mid-training used

“DeepSeek incorporates agentic data during what it calls the 'mid-training phase'”

reasoning control 3

Thinking mode used

“Both V4-Pro and V4-Flash support three modes: Non-think, Think High, and Think Max”

Persistent reasoning history used

“all reasoning content is fully preserved throughout the entire conversation.”

Think-tag response formatting used

“we utilize specialized response formats demarcated by the <think> and </think> tokens.”

KV cache management 6

Customized heterogeneous KV-cache layout core

“we design a customized KV cache layout.”

Dynamic allocation of fixed-size state-cache pools used

“we pre-allocate a fixed- and limited-size pool of state caches, and dynamically assign it to each sequence.”

KV-cache and sparse-attention-kernel co-design used

“Achieving this requires co-designing the KV cache layout and the sparse attention kernel.”

On-disk KV-cache storage for shared-prefix reuse used

“we leverage an on-disk KV cache storage mechanism to eliminate repeated prefilling for shared-prefix requests.”

Periodic cache checkpointing optional

“This strategy checkpoints SWA KV entries of the last tokens within every tokens, where is a tunable parameter.”

Zero SWA caching optional

“This strategy does not store any SWA KV entries.”

inference quantization 2

FP4 attention-indexer precision used

“attention computation within the lightning indexer is performed in FP4 precision”

FP8 precision used

“FP8 precision is applied to the remaining dimensions”

inference kernel 9

Batch-invariant deterministic kernels core

“we implement end-to-end, bitwise batch-invariant, and deterministic kernels with minimal performance overhead”

DeepGEMM-based batch-invariant matrix multiplication used

“Therefore, we replace it end-to-end with DeepGEMM.”

Distributed shared memory for cross-SM attention exchange used

“the second kernel utilizes distributed shared memory within thread-block clusters, enabling high-speed data exchange across SMs”

Dual-kernel batch-invariant attention decoding used

“To address this, we develop a dual-kernel strategy for batch-invariant decoding.”

Fused mHC kernels used

“we carefully design and implement fused kernels of mHC for both training and inference.”

Host Codegen used

“We mitigate this overhead with Host Codegen, which moves most host-side logic into generated host code”

Per-SM accumulation buffers with deterministic global summation used

“we allocate separate accumulation buffers for each SM, followed by a global deterministic summation across all buffers.”

Separate split-K outputs with deterministic reduction used

“we output each split part separately and perform a deterministic reduction in a subsequent kernel”

Token-order preprocessing and cross-rank buffer isolation used

“we design a token order pre-processing mechanism within each single rank, combined with buffer isolation across multiple ranks.”

agentic scaffolding 4

XML-based tool-call schema with DSML token used

“we introduce a new tool-call schema that employs a special "|DSML|" token and utilizes an XML-based format for tool invocations”

Agentic search used

“the "thinking" mode utilizes agentic search.”

Retrieval-Augmented Search used

“the "non-think" mode employs Retrieval-Augmented Search (RAG)”

Sandbox infrastructure (DSec) used

“The sandbox infrastructure (DSec) manages hundreds of thousands of concurrent sandbox instances”

Not used 1

Avoiding split-K for batch invariance not used

inference kernel “Therefore, we abandon split-k in most scenarios, which, however, may cause performance degradation.”

infrastructure service 2

Write-ahead log (WAL) used

“we implement a token-granular Write-Ahead Log (WAL) for each generation request.”

Z3 SMT solver integration used

“we integrate the Z3 SMT solver into TileLang’s algebraic system”

human & real-world evaluation 3

Internal engineering-task evaluation used

“DeepSeek curated approximately 200 tasks from 50+ internal engineers across PyTorch, CUDA, Rust, and C++”

Pairwise comparison for Chinese writing used

“DeepSeek ran pairwise comparisons across 3,170 functional writing tasks and 2,837 creative writing tasks.”

White-collar enterprise-task evaluation used

“DeepSeek built a suite of 30 advanced Chinese professional workflows spanning 13 industries”

unfiled 5

fine-grained EP scheme used

“we introduce a finer-grained expert partitioning scheme... forms a fine-grained pipeline among experts”

Post-training pipeline used

“comprehensive post-training pipeline. The post-training features a two-stage paradigm: independent cultivation of domain-specific experts…”

TileLang used

“We adopt TileLang to develop a set of fused kernels to replace the vast majority of them”

Two-stage contextual-parallel communication for compressed attention used

“To address these challenges, we design a two-stage communication approach.”

1 more mentioned or evaluated
self-verification evaluated

“candidate natural-language solutions are first generated and filtered by…”

Further reading

Picked by hand, not extracted: where to read more, not evidence for anything on this page.

Sources

The curated source list for this model. "not fetched" means the URL is recorded but its text was not read in the current run.

SourceKindPublisherStatus
api-docs.deepseek.com/news/news260424official blogDeepSeekread
arxiv.org/abs/2606.19348technical reportDeepSeekread
fe-static.deepseek.com/chat/transparency/deepseek-V4-model-card-EN.pdftechnical reportDeepSeekread
huggingface.co/deepseek-ai/DeepSeek-V4-Promodel cardDeepSeekread
morphllm.com/deepseek-v4third party analysisMorphnot fetched
kili-technology.com/blog/data-story-deepseek-v4third party analysisKili Technologyread
recipes.vllm.ai/deepseek-ai/DeepSeek-V4-Provendor docsvLLMnot fetched
lmsys.org/blog/2026-04-25-deepseek-v4vendor docsLMSYSnot fetched
docs.sglang.io/cookbook/autoregressive/DeepSeek/DeepSeek-V4vendor docsSGLangnot fetched
↑