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.
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.