diff --git a/docs/cookbook/autoregressive/DeepSeek/DeepSeek-V4.mdx b/docs/cookbook/autoregressive/DeepSeek/DeepSeek-V4.mdx
index 71fb0a706..bdab2b9ad 100644
--- a/docs/cookbook/autoregressive/DeepSeek/DeepSeek-V4.mdx
+++ b/docs/cookbook/autoregressive/DeepSeek/DeepSeek-V4.mdx
@@ -1,7 +1,6 @@
---
title: DeepSeek-V4
description: "Deploy DeepSeek-V4 with SGLang — verified launch commands, benchmarks, and tuning for Flash Official (0731), Flash, Flash Vision (Exp), Pro, and Pro Official (0813)."
-tag: NEW
---
## Deployment
diff --git a/docs/cookbook/autoregressive/DeepSeek/DeepSeek-V4_1.mdx b/docs/cookbook/autoregressive/DeepSeek/DeepSeek-V4_1.mdx
new file mode 100644
index 000000000..f1f9fa46a
--- /dev/null
+++ b/docs/cookbook/autoregressive/DeepSeek/DeepSeek-V4_1.mdx
@@ -0,0 +1,190 @@
+---
+title: DeepSeek-V4.1
+description: "Deploy DeepSeek-V4.1 Flash with SGLang — launch recipes, feature compatibility, and tuning notes for GB300, H200, B200, B300 and MI350X."
+tag: NEW
+---
+
+## Deployment
+
+
+
+
+
+For all methods and hardware platforms, see the [official SGLang installation guide](../../../docs/get-started/install). The two paths below match the **Python / Docker** toggle in the command panel.
+
+
+
+
+
+DeepSeek-V4.1 Flash support has **not shipped in an SGLang release yet**, so a stock `pip install sglang` cannot serve it. Use the preview Docker image below.
+
+
+
+
+
+For how to launch the image, see [Install → Method 3: Using Docker](../../../docs/get-started/install#method-3-using-docker).
+
+**NVIDIA GPUs** — every NVIDIA cell on this page uses the preview build `lmsysorg/sglang:dev-dsv41` (H200 / B200 / B300 / GB300); the command panel picks it automatically.
+
+```bash Command
+docker pull lmsysorg/sglang:dev-dsv41
+
+docker run --gpus all \
+ --shm-size 32g \
+ -p 30000:30000 \
+ -v ~/.cache/huggingface:/root/.cache/huggingface \
+ --env "HF_TOKEN=" \
+ --ipc=host \
+ lmsysorg/sglang:dev-dsv41 \
+ sglang serve
+
+
+
+
+
+Pick your hardware + recipe to generate the launch command:
+
+- **Low-Latency** — fastest reply for a single user. Pick for chat.
+- **High-Throughput** — most tokens per second across many users. Best for batch jobs.
+
+import { Deployment } from "/src/snippets/_deployment.jsx";
+import { config } from "/src/snippets/configs/deepseek-ai/deepseek-v4_1.jsx";
+
+
+
+
+## Playground
+
+The Playground is where you experiment with **SGLang features beyond the verified matrix**. The Deploy panel above only emits combinations the SGLang team has signed off on; the Playground lets you turn on additional knobs on top of whichever cell the Deploy panel is currently showing.
+
+import { Playground } from "/src/snippets/_playground.jsx";
+
+
+
+
+## 1. Model Introduction
+
+**DeepSeek-V4.1 Flash** is a sparse-attention Mixture-of-Experts model (`model_type: deepseek_v4.1`) served through SGLang's `dsv4` backend: 40 decoder layers, 384 routed experts at top-6 plus one shared expert, fp8 dense weights at a 32-wide `ue8m0` block scale with fp4 routed experts. It also carries **DSpark**, its own three-stage speculative draft, which the Low-Latency recipe turns on.
+
+**Architecture.** Every layer keeps one 512-wide KV latent per position and uses it as both key and value for all 64 query heads, with no separate value projection. Each layer reads two stores that behave oppositely: **compressed latents**, produced only at source layers and shared forward, collapsing 2 positions into 1 in layers 2–19 and 1-to-1 from layer 20 on; and a **128-position sliding window**, recomputed per layer from that layer's own activations, so it can never be shared but also never grows with context. Consumers address a source's cache by plain `loc // ratio` arithmetic with no mapping table, so compressed state lives and dies with the full prefix for free. The residual stream is four parallel copies mixed by a per-token doubly stochastic matrix; each sublayer's mixing coefficients are consumed by the *next* sublayer, which lets that projection overlap the main GEMMs.
+
+**Sparse retrieval.** KV source layers and index source layers are different lists — four of the former, eight of the latter. The four extra index layers produce no keys at all; they re-score layer 20's keys with their own query, so retrieval decisions are made twice as often as keys are stored. Each retrieving layer picks a top-512 candidate set.
+
+**Engram.** An additive n-gram hash memory at two layers. Token ids are normalized *before* hashing, so `" The"`, `"the"` and `"THE"` cannot fork into separate rows. Its two fp8 tables are the largest single block of weight in the checkpoint, and by default they load row-sharded across the TP group, which costs an all-reduce per engram layer. `SGLANG_ENABLE_DSV41_ENGRAM_HOST_TABLE=1` (**opt-in**) moves them to one shared host copy instead: both all-reduces disappear, the freed HBM goes to the KV pool, and output is bitwise unchanged — at the cost of host RAM, a longer load, and needing huge-page backing to keep the gather cheap.
+
+**SWA bounded replay.** Because the window store is per-layer and cheap to rebuild, it need not all be recomputed. `--enable-decoder-swa-bounded-replay` (**opt-in**) runs the early layers over the whole extend and the late layers over only each request's last 128 tokens, sharing late-layer KV from source layer 20. Prefill gets materially faster. It is validated on the decode path only, refuses prompt logprobs by design, is not numerically equivalent to full prefill, and is excluded at launch with the prefill CUDA graph and with DP attention.
+
+**Kernels.** At decode token counts these kernels are launch-bound rather than bandwidth-bound, so the work is fusion and overlap: the compressor projection, ratio-2 pooling, RoPE with fp4 quantization and indexer packing, paged fp4 indexer scoring with top-k resolved straight to cache addresses, and the mHC statistics and Sinkhorn — with compression, indexing and mHC overlapped against attention and FFN on dedicated streams. All of it is selected automatically; the environment switches it once sat behind were removed, so there is nothing to turn on. One caveat outranks the fusions: **output is not bitwise stable across batch composition today** — two default kernels are shape-guarded to a single token — and `--enable-deterministic-inference` is refused on this backend.
+
+**Recommended generation:** reasoning evaluations were run at `temperature=1.0`, `top_p=0.95` with reasoning effort `max` (informational — do not hardcode these in application code).
+
+**Resources:** [HuggingFace](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash).
+
+## 2. Configuration Tips
+
+### Do not override the backends
+
+`--attention-backend`, `--moe-runner-backend` and `--fp8-gemm-backend` are selected automatically from the model, hardware, forward mode and shape. On GB300 they resolve to `dsv4` / `flashinfer_mxfp4` / `flashinfer_cutedsl`. Confirm them in the startup log rather than passing them.
+
+Overriding them is the most common cause of a disappointing measurement: it leaves the 32-wide ue8m0 blocks on the Triton `_w8a8_block_fp8_matmul` fallback, which dominates the decode step and costs most of the model's bs=1 throughput. If your decode rate looks like a small fraction of what you expected, check the resolved backends first.
+
+## 3. Advanced Usage
+
+### 3.1 Reasoning
+
+Enable the reasoning parser — `--reasoning-parser auto` resolves to `deepseek-v41` (toggle **Reasoning Parser** in the **Parsers** card of the [Playground above](#playground)) to separate thinking from the final answer. The parser puts the thinking block in `reasoning_content` and the answer in `content`; without it both arrive concatenated in `content`.
+
+
+
+```python Example
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")
+resp = client.chat.completions.create(
+ model="deepseek-ai/DeepSeek-V4.1-Flash",
+ messages=[{"role": "user", "content": "What is 15% of 240?"}],
+)
+msg = resp.choices[0].message
+print("Reasoning:", getattr(msg, "reasoning_content", None))
+print("Answer:", msg.content)
+```
+
+
+
+Reasoning effort is part of the request contract for this model: send `reasoning_effort` on the request, either as a tier or as an integer budget. Tiers with no V4.1 counterpart (`none`, `minimal`, `medium`) log a warning and fall back to the server-side default rather than erroring; that default is `high`, and `SGLANG_DSV41_REASONING_EFFORT` overrides it.
+
+### 3.2 Tool Calling
+
+Enable the tool-call parser — `--tool-call-parser auto` resolves to `deepseekv41` (toggle **Tool Call Parser** in the **Parsers** card of the [Playground above](#playground)) to surface structured tool calls via `message.tool_calls`. DeepSeek-V4.1 uses spaced DSML tool tags, which the stock DeepSeek-V4 detector does not parse — the `deepseekv41` detector is required.
+
+
+
+```python Example
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")
+tools = [{
+ "type": "function",
+ "function": {
+ "name": "get_weather",
+ "description": "Get the current weather in a city",
+ "parameters": {
+ "type": "object",
+ "properties": {"location": {"type": "string"}},
+ "required": ["location"],
+ },
+ },
+}]
+
+resp = client.chat.completions.create(
+ model="deepseek-ai/DeepSeek-V4.1-Flash",
+ messages=[{"role": "user", "content": "What's the weather in Beijing?"}],
+ tools=tools,
+)
+choice = resp.choices[0]
+print("finish_reason:", choice.finish_reason)
+print("tool_calls:", choice.message.tool_calls)
+print("reasoning:", getattr(choice.message, "reasoning_content", None))
+```
+
+
+
+A successful call returns `finish_reason: "tool_calls"` with a single `get_weather` entry whose arguments carry the requested location. If you see the raw DSML markup in `content` instead, the parser flag is missing.
+
+### 3.3 Speculative Decoding (DSpark)
+
+DSpark is DeepSeek-V4.1 Flash's own bundled draft — there is no EAGLE or MTP path for this model, and no `--speculative-num-steps` knob (the draft-token count is resolved from the checkpoint). Turn it on with `--speculative-algorithm DSPARK --speculative-dspark-block-size 5`, which is what the Low-Latency cells do.
+
+What to expect:
+
+- A DSpark step costs meaningfully more than a plain decode step, so the win at bs=1 is roughly the accept length divided by that fixed step cost. It is a real speed-up on interactive workloads, but not proportional to the number of draft tokens.
+- Acceptance is strongly workload-dependent — highest on maths and code, lower on open-ended chat, lower still on agentic traces. Size your expectations from the workload you actually run, and measure it rather than assuming.
+- The step cost does not move with accept length or with the draft block size, so tuning `--speculative-dspark-block-size` will not buy throughput. This is also why the High-Throughput recipe turns speculation off: at large batch the fixed step cost stops paying for itself.
+
+### 3.4 PD Disaggregation
+
+Prefill/decode disaggregation is validated token-identical against a single server across 32 greedy prompts, with GSM8K matching through the router. Use the **PD Disaggregation** card in the Playground to generate the prefill role, the decode role and the router command.
+
+One deployment note: Mooncake needs the RDMA fabric visible inside the container, so launch with `--device /dev/infiniband:/dev/infiniband --cap-add IPC_LOCK --ulimit memlock=-1`. Without it Mooncake selects its NVLink transport, which only serves buffers from its own allocator and fails with `Requested address ... not found`. If you hit that, force TCP with `MOONCAKE_PROTOCOL=tcp` and `MC_FORCE_TCP=1` — the Playground's Mooncake option sets both.
+
+PD and speculative decoding cannot be combined.
diff --git a/docs/cookbook/autoregressive/intro.mdx b/docs/cookbook/autoregressive/intro.mdx
index 3cf50469d..e9eb9215b 100644
--- a/docs/cookbook/autoregressive/intro.mdx
+++ b/docs/cookbook/autoregressive/intro.mdx
@@ -40,7 +40,7 @@ metatags:
" },
+ CURL_HOST: { target: "curl", label: "Server host", default: "localhost" },
+ CURL_PORT: { target: "curl", label: "Server port", default: "30000" },
+ },
+
+ curl: `curl http://{{CURL_HOST}}:{{CURL_PORT}}/v1/chat/completions \\
+-H 'Content-Type: application/json' \\
+-d '{ "model": "{{MODEL_NAME}}", "messages": [{"role":"user","content":"Hello"}] }'`,
+
+ dockerImages: {
+ // DeepSeek-V4.1 support has not shipped in a release yet.
+ h200: "lmsysorg/sglang:dev-dsv41",
+ b200: "lmsysorg/sglang:dev-dsv41",
+ b300: "lmsysorg/sglang:dev-dsv41",
+ gb300: "lmsysorg/sglang:dev-dsv41",
+ mi350x: "lmsysorg/sglang:dev-dsv41-mi35x",
+ },
+
+ github: {
+ cookbookModel: "deepseek-ai/deepseek-v4.1",
+ },
+
+ playgroundFeatures: {
+
+ attention: {
+ knobs: [
+ { id: "tp", label: "TP", values: [null, 4, 8] },
+ ],
+ },
+
+ // No backend chooser: `flashinfer_mxfp4` is selected automatically and is the
+ // only MoE runner this model has run on. EP tracks TP.
+ moe: {
+ ep: { label: "EP", values: [null, 4, 8] },
+ },
+
+ // Both parsers default to None; without them the DSML tool-call block and the
+ // thinking block arrive as raw text inside `content`.
+ parsers: {
+ items: [
+ { id: "reasoning", label: "Reasoning Parser", flag: "--reasoning-parser auto" },
+ { id: "toolCall", label: "Tool Call Parser", flag: "--tool-call-parser auto" },
+ ],
+ },
+
+ // DSpark is the model's bundled 3-stage draft. There is no EAGLE/MTP path and
+ // no `--speculative-num-steps` knob.
+ speculative: {
+ options: [
+ { id: "current", label: "Inherited from base" },
+ { id: "off", label: "Off (greedy)" },
+ { id: "dspark", label: "DSpark",
+ flags: ["--speculative-algorithm DSPARK", "--speculative-dspark-block-size 5"] },
+ ],
+ },
+
+ pdDisagg: {
+ incompatibleSpeculativeAlgorithms: ["DSPARK"],
+ modes: [
+ { id: "off", label: "Off" },
+ { id: "prefill", label: "Prefill role" },
+ { id: "decode", label: "Decode role" },
+ ],
+ transferBackends: [
+ // Fallback for hosts where the RDMA fabric is not visible in the container:
+ // Mooncake then picks its NVLink transport, which only serves buffers from
+ // its own allocator and fails to find the peer address.
+ { id: "mooncake", label: "Mooncake (TCP)",
+ env: ["MOONCAKE_PROTOCOL=tcp", "MC_FORCE_TCP=1"] },
+ ],
+ ibDevices: [{ id: "auto", label: "Auto" }],
+ router: {
+ port: 8000,
+ command:
+`sglang-router launch \\
+ --pd-disaggregation \\
+ --prefill http://:{{PREFILL_PORT}} 8998 \\
+ --decode http://:{{DECODE_PORT}} \\
+ --host 0.0.0.0 --port {{ROUTER_PORT}}`,
+ },
+ },
+
+ flagSelects: [
+ {
+ id: "dsparkBlockSize",
+ title: "DSpark Proposed Draft Tokens",
+ showWhen: (base) => base.specAlgorithm === "DSPARK",
+ control: "slider",
+ stripPrefixes: ["--speculative-dspark-block-size"],
+ options: [
+ { id: "auto", label: "Checkpoint default" },
+ { id: "1", label: "1", flags: ["--speculative-dspark-block-size 1"] },
+ { id: "2", label: "2", flags: ["--speculative-dspark-block-size 2"] },
+ { id: "3", label: "3", flags: ["--speculative-dspark-block-size 3"] },
+ { id: "4", label: "4", flags: ["--speculative-dspark-block-size 4"] },
+ { id: "5", label: "5", flags: ["--speculative-dspark-block-size 5"] },
+ ],
+ },
+ {
+ id: "engramHostTable",
+ title: "Engram Host-Resident Tables",
+ control: "select",
+ options: [
+ { id: "off", label: "Off (default)" },
+ { id: "on", label: "On (larger KV pool)",
+ env: ["SGLANG_ENABLE_DSV41_ENGRAM_HOST_TABLE=1"] },
+ ],
+ },
+ {
+ id: "decoderSwaBoundedReplay",
+ title: "Decoder SWA Bounded Replay",
+ control: "select",
+ options: [
+ { id: "off", label: "Off (default)" },
+ { id: "on", label: "On (faster prefill)",
+ flags: ["--enable-decoder-swa-bounded-replay"] },
+ ],
+ },
+ ],
+ },
+
+ cells: [
+
+ // ---------- GB300: 4x GB300 (SM103), TP4 + EP4. Reference platform. ----------
+ {
+ match: { hw: "gb300", strategy: "low-latency" },
+ nnodes: 1,
+ verified: true,
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ // The derived value OOMs at 128K shapes while capturing the verify graphs.
+ "--mem-fraction-static 0.8",
+ "--speculative-algorithm DSPARK",
+ "--speculative-dspark-block-size 5",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+ {
+ match: { hw: "gb300", strategy: "high-throughput" },
+ nnodes: 1,
+ verified: true,
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ // No speculation: the DSpark step has a fixed cost over a plain decode
+ // step, so it stops paying for itself once the batch is large.
+ "--max-running-requests 256",
+ // Leave the backends alone — they resolve to dsv4 / flashinfer_mxfp4 /
+ // flashinfer_cutedsl. Overriding them is the usual cause of slow decode.
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+
+ // ---------- H200: 8x H200, TP8 + EP8. No MXFP8 dense path on Hopper;
+ // verification round open. ----------
+ {
+ match: { hw: "h200", strategy: "low-latency" },
+ nnodes: 1,
+ verificationStatus: "in-progress",
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 8",
+ "--ep-size 8",
+ "--attention-backend dsv4",
+ "--moe-runner-backend flashinfer_mxfp4",
+ "--enable-decoder-swa-bounded-replay",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+ {
+ match: { hw: "h200", strategy: "high-throughput" },
+ nnodes: 1,
+ verificationStatus: "in-progress",
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 8",
+ "--ep-size 8",
+ "--attention-backend dsv4",
+ "--moe-runner-backend flashinfer_mxfp4",
+ "--max-running-requests 256",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+
+ // ---------- B200 / B300: verification round open. Mirrors the GB300 recipe
+ // because the kernels dispatch by architecture family. ----------
+ {
+ match: { hw: "b200", strategy: "low-latency" },
+ nnodes: 1,
+ verificationStatus: "in-progress",
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ "--mem-fraction-static 0.8",
+ "--speculative-algorithm DSPARK",
+ "--speculative-dspark-block-size 5",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+ {
+ match: { hw: "b200", strategy: "high-throughput" },
+ nnodes: 1,
+ verificationStatus: "in-progress",
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ "--max-running-requests 256",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+ {
+ match: { hw: "b300", strategy: "low-latency" },
+ nnodes: 1,
+ verificationStatus: "in-progress",
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ "--mem-fraction-static 0.8",
+ "--speculative-algorithm DSPARK",
+ "--speculative-dspark-block-size 5",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+ {
+ match: { hw: "b300", strategy: "high-throughput" },
+ nnodes: 1,
+ verificationStatus: "in-progress",
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ "--max-running-requests 256",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+
+ // ---------- MI350X: 4x MI350X (gfx950), TP4 + EP4. Speculative decoding is
+ // rejected on ROCm, so there is one recipe. ----------
+ {
+ // DSpark runs on MI350X but is off by default; this cell turns it on.
+ match: { hw: "mi350x", strategy: "low-latency" },
+ nnodes: 1,
+ verified: true,
+ env: [
+ // Load-bearing: without it the fp4 experts land in the Triton
+ // fused-experts runner and assert on the hidden size.
+ "SGLANG_USE_AITER=1",
+ "SGLANG_MOE_PADDING=1",
+ // Required for run-to-run repeatable output: forces the FlyDSL MoE
+ // down-projection onto a per-slot reduce instead of atomics.
+ "AITER_FLYDSL_FORCE_REDUCE=1",
+ "ROCM_QUICK_REDUCE_QUANTIZATION=NONE",
+ ],
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ "--disable-radix-cache",
+ "--mem-fraction-static 0.8",
+ "--speculative-algorithm DSPARK",
+ "--speculative-dspark-block-size 5",
+ "--cuda-graph-max-bs 64",
+ "--cuda-graph-backend-prefill breakable",
+ "--cuda-graph-max-bs-prefill 4096",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+ {
+ // The attention backend and mem-fraction-static are the resolved
+ // defaults on HIP, so this cell leaves both alone.
+ match: { hw: "mi350x", strategy: "high-throughput" },
+ nnodes: 1,
+ verified: true,
+ env: [
+ // Load-bearing: without it the fp4 experts land in the Triton
+ // fused-experts runner and assert on the hidden size.
+ "SGLANG_USE_AITER=1",
+ "SGLANG_MOE_PADDING=1",
+ // Required for run-to-run repeatable output: forces the FlyDSL MoE
+ // down-projection onto a per-slot reduce instead of atomics.
+ "AITER_FLYDSL_FORCE_REDUCE=1",
+ "ROCM_QUICK_REDUCE_QUANTIZATION=NONE",
+ ],
+ flags: [
+ "--trust-remote-code",
+ "--model-path {{MODEL_NAME}}",
+ "--tp 4",
+ "--ep-size 4",
+ "--disable-radix-cache",
+ "--cuda-graph-backend-prefill breakable",
+ "--cuda-graph-max-bs-prefill 4096",
+ "--reasoning-parser auto",
+ "--tool-call-parser auto",
+ "--host {{HOST_IP}}",
+ "--port {{PORT}}",
+ ],
+ },
+ ],
+};
diff --git a/docs/src/snippets/configs/popular-models.jsx b/docs/src/snippets/configs/popular-models.jsx
index d2df38a71..7d2c08dfc 100644
--- a/docs/src/snippets/configs/popular-models.jsx
+++ b/docs/src/snippets/configs/popular-models.jsx
@@ -12,6 +12,23 @@
// paraphrasing that page's own opening.
export const popularModels = [
+ {
+ name: "DeepSeek-V4.1-Flash",
+ vendor: "DeepSeek",
+ href: "/cookbook/autoregressive/DeepSeek/DeepSeek-V4_1",
+ logo: "/cards/logos/deepseek.png",
+ badge: "New",
+ tags: ["5 platforms", "Engram + DSpark", "FP8 dense / FP4 MoE"],
+ hero: {
+ eyebrow: "Featured model \u00b7 New",
+ headline: "Meet DeepSeek-V4.1 Flash on SGLang",
+ blurb:
+ "DeepSeek's sparse-attention Mixture-of-Experts model, served through SGLang's `dsv4` backend \u2014 pairing multi-ratio compressed KV pools behind FlashMLA with a learned sparse index that picks a top-512 candidate set per query, an mHC mixing stage, and Engram, an n-gram hash memory whose two fp8 tables are roughly 40% of the checkpoint. It ships DSpark, its own three-stage speculative draft. Recipes cover GB300, H200, B200, B300 and AMD MI350X.",
+ tags: ["384 experts / top-6", "Sparse index + Engram", "NVIDIA + AMD"],
+ cta: "Open the DeepSeek-V4.1 Flash cookbook",
+ caption: "DeepSeek-V4.1 Flash deployment guide",
+ },
+ },
{
name: "Qwen3.8-Flash-Next",
vendor: "Qwen",