Skip to main content

Deployment

For all methods and hardware platforms, see the official SGLang installation guide. The two paths below match the Python / Docker toggle in the command panel.
Command
Then run the Python output of the command panel below in that environment. Ling-3.0-flash-VL support requires sglang with sgl-project/sglang#38526 (or newer); until it merges, install directly from the PR head:
Command
Video input needs decord or torchcodec in the environment; audio is not supported. Downloading the checkpoint requires HF_TOKEN.
Pick your hardware to generate the launch command. The checkpoint ships in BF16 with an FP8 variant, and each GPU family carries one Balanced recipe sized so the ~250 GB of BF16 weights fit with KV-cache headroom: --tp 4 on 288 GB-class (GB300, B300) and 141 GB-class (B200, H200) GPUs, and --tp 8 on H100.

Playground

The Playground is where you experiment with SGLang features beyond the verified matrix. The Deploy panel above only emits the recipes on this page; the Playground lets you turn on additional knobs on top of whichever cell the Deploy panel is currently showing.

1. Model Introduction

Ling-3.0-flash-VL is the vision-language member of the BailingMoeV3 family. Its language backbone is the Ling-3.0-flash hybrid-attention Mixture-of-Experts (MoE) model: 42 layers that interleave Kimi Delta Attention (KDA) linear-attention layers with gated Multi-head Latent Attention (MLA) full-attention layers, on top of a fine-grained MoE feed-forward network with 512 routed experts (8 active per token) plus a shared expert. A 27-layer vision encoder (0.4B parameters, 16-pixel patches with 2×2 spatial merging and paired frames for video) feeds image and video tokens into that backbone through a small MLP projector. In total the checkpoint holds ~125B parameters with ~5.1B active per token, so per-token inference cost stays close to a small model. It is a thinking model: the chat template turns chain-of-thought on by default and exposes an enable_thinking switch. It supports structured tool calling. Inputs are text, images, and video; audio is not supported. Native context length is 128K tokens. Unlike Ling-3.0-flash, the VL checkpoint ships no built-in MTP draft layer, so there is no speculative-decoding recipe. Available Models: License: MIT Recommended generation: temperature=1.0, top_p=0.95, top_k=20 (from the checkpoint’s generation_config.json; SGLang applies these defaults, so the samples below do not set them). Resources: HuggingFace.

2. Configuration Tips

  • --trust-remote-code is required. The checkpoint declares its config and multimodal processor through auto_map, and SGLang’s native implementation loads the image/video preprocessing and the chat template from those files. Serving from the Hub repo or from a local snapshot needs no extra environment setup.
  • BF16 weights take ~250 GB. The recipes use --tp 4 on 288 GB-class (GB300, B300) and 141 GB-class (B200, H200) GPUs and --tp 8 on H100, with the default memory pool. The 4×GB300 and 4×H200 cells are validated end to end; the rest are sized by the same rule and carry the unverified badge. Adjust TP in the Attention Parallelism card of the Playground.
  • HiCache is supported: --enable-hierarchical-cache attaches the hierarchical cache to the hybrid SSM state (verified with CPU offload; L3 storage backends such as Mooncake are untested). On shared hosts, set an explicit --hicache-size <GB> — the default ratio can request more host RAM than is free.
  • Vision token budget: the encoder emits one token per 32×32-pixel block after merging, so a 1280×720 image costs about 880 tokens and the processor’s max_pixels of 4,194,304 caps a single image at roughly 4,100 tokens. Video frames are paired before patching; the sample clip in §3.2 costs 4,224 tokens. Size --chunked-prefill-size and --max-running-requests with these counts in mind for image-heavy traffic.
  • Parsers: the generated recipes include --reasoning-parser auto --tool-call-parser auto by default. Both resolve to ling3 from the chat template (the server logs Auto-detected --reasoning-parser as ling3 from chat template and the same for the tool-call parser), so no model-specific parser name is needed; the explicit form --reasoning-parser ling3 --tool-call-parser ling3 is equivalent. With the parsers on, reasoning is returned in message.reasoning_content and structured tool calls in message.tool_calls; without them, message.content carries the reasoning followed by </think> and the answer (the opening <think> tag sits in the prompt and is not echoed).
  • Thinking is on by default (enable_thinking defaults to true in the chat template, and the ling3 reasoning parser follows that default). Turn it off per request with "chat_template_kwargs": {"enable_thinking": false} (§3.3).
  • Native context is 128K, and the generated recipes default to the 256K YaRN variant (--context-length 262144 plus the rope_scaling override and SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1), matching the model card. For the native 128K window, drop all three from the command.
  • Audio content parts are rejected before preprocessing; send images as image_url and clips as video_url content parts (§3).
  • The FP8 variant (inclusionAI/Ling-3.0-flash-VL-FP8) uses 128×128 block quantization, so plain TP must keep 768 ÷ tp divisible by 128 (TP 1, 2, 3, or 6 — TP=4 fails to load). The FP8 recipes therefore pair TP with expert parallelism (--tp 4 --ep 4, --tp 8 --ep 8), which keeps experts whole per rank and is verified on 4×GB300; TP=2 without EP also works. The BF16 checkpoint can also be quantized online with --quantization fp8; measured accuracy and speed for both paths are in the benchmark cards below.

3. Advanced Usage

The examples below were run against a server launched with the recipe above plus --reasoning-parser auto --tool-call-parser auto, which resolves both parsers to ling3 (§2). Reasoning therefore arrives in message.reasoning_content and the answer in message.content.

3.1 Image Understanding

Send images as OpenAI-style image_url content parts:
Example
Output

3.2 Video Understanding

Clips go in as video_url content parts. The processor samples and pairs frames itself; no client-side frame extraction is needed:
Example
Output

3.3 Thinking Mode

Thinking is on by default. Disable it for a single request through the chat template’s enable_thinking kwarg; the model then answers directly and reasoning_content stays empty:
Example
Output

3.4 Tool Calling

With the tool-call parser on, structured calls are parsed into message.tool_calls and finish_reason is tool_calls. Send the tool result back as a tool message to get the final answer; on this thinking model the follow-up turn may put text in reasoning_content as well as content, so print both:
Example
Output
For more API examples, see the SGLang OpenAI Vision API Guide and the Tool Parser guide.