Executable programs and extensions

What server do you need to run Ling 3.1 Flash?

Official recipes use a multi-GPU server for a 574 GB checkpoint.

Ling 3.1 Flash is an MoE1 language model with 560B total parameters and 25B active per token2. Official SGLang recipes run its 574 GB FP83 checkpoint4 on 8×H200 or 4×GB300 servers.

What Ling 3.1 Flash does

Ling 3.1 Flash generates answers from text prompts5 for coding and agent tasks. It has 560B total parameters, activates 25B per token, and supports up to a 1M-token context. The official FP8 checkpoint file listing totals about 574 GB. Model card and files

Context length6 is the maximum input a model can process at once. Longer documents also require more memory for the KV cache7 and inference8 engine. Check the available GPU9 memory and document length, then set the context to fit the task.

A desk with a compact desktop and PC tower beside a monitor
Check runtime memory needs as well as the model files.

Plan around the official server recipes and 574 GB checkpoint

The official SGLang quick start uses TP8 and EP8 across eight H200 GPUs, or TP4 and EP4 across four GB300 GPUs. The model files total about 574 GB; inference also needs memory for the KV cache and runtime10, depending on context length. Check storage and GPU capacity, then choose a context length for your requests. SGLang setup

Tensor parallelism11 (TP) splits computation across GPUs, while expert parallelism (EP) distributes MoE experts. Use the table to match these settings to the official server recipes, then allow for KV-cache and runtime memory at your actual context length.

SGLang configurations in the official model card
Server GPUsTensor / expert parallelRuntime
8×H200TP8 / EP8SGLang day-0 image
4×GB300TP4 / EP4SGLang day-0 image

Start the server and send a first request

First, pull the SGLang container as described in the model card. The command below targets 8×H200 and uses --host 127.0.0.1 instead of the official example's 0.0.0.0, keeping access on the same machine. Add network controls and authentication before allowing other computers to connect. Mount the Hugging Face cache on host storage so the roughly 574 GB checkpoint does not need to be downloaded again after each container removal. Cache locations

Start the SGLang server
docker pull lmsysorg/sglang:dev-ling-3.1-flash
mkdir -p "$HOME/.cache/huggingface"

docker run --gpus all --network host --ipc=host --rm \
  -v "$HOME/.cache/huggingface:/root/.cache/huggingface" \
  lmsysorg/sglang:dev-ling-3.1-flash \
  python3 -m sglang.launch_server \
    --model-path inclusionAI/Ling-3.1-flash \
    --tp 8 --ep 8 \
    --speculative-algorithm NEXTN \
    --host 127.0.0.1 --port 30000

When the server is ready, send a request to http://127.0.0.1:30000/v1/chat/completions. The OpenAI-compatible API12 uses the model ID Ling-3.1-flash; refer to the model card examples for enable_thinking, temperature, top-k, and top-p.

First send a short text prompt and confirm that a response arrives, then test your document length and tool calls13. If there is no response, inspect the container logs for model loading errors or insufficient GPU memory. Official setup

Send a first text request
curl -s http://127.0.0.1:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"Ling-3.1-flash","messages":[{"role":"user","content":"Write a one-sentence summary."}],"chat_template_kwargs":{"enable_thinking":true},"temperature":1.0,"top_k":20,"top_p":0.95,"stream":true}'
A workspace with two compact desktops connected by cable
Large models may need a server that distributes them across accelerators.

What changed in the October 19 checkpoint

A checkpoint dated October 19 (Ling-3.1-flash-1019) is up. The architecture and window are unchanged and the post-training differs; 560B total with 25B active, a 1M window and the 8×H200 recipe all stay as they were.

The gains look like this: the Artificial Analysis intelligence index moves from 41 to 44, AA-Briefcase from about 1400 to 1524 Elo, AutomationBench from 62 to 68 percent, CritPt from 18 to 26 and SciCode from 54 to 57.

What moved in the October 19 checkpoint
MeasureBeforeOctober 19
Artificial Analysis index4144
AA-Briefcase (Elo)14001524
AutomationBench62%68%
CritPt18%26%
SciCode54%57%

Dated checkpoints get mixed up with their predecessor: check which revision --model-path resolves to and which revision sits in your cache.

Decide whether it fits your workload

To check whether you need long context or coding and agent features, choose a representative task and repeat it with the same document and output length. Record time to first token14 and total completion time to see whether 1M context or reasoning options help your work. Published benchmark throughput15 applies to its test hardware and conditions.

Before providing the API to teammates, decide who can access it and how long request and server logs will be retained. For internal documents, also check the permitted scope of use.

A meeting table with a laptop, microphone, and notebooks
Choose how the client connects to the model server.

Terminology notes

  1. MoE — A model architecture that selects some of several expert subnetworks for each input. Total parameters can differ from the number activated for one token.

    Back to the text
  2. Token — A unit into which a model divides input or output for processing.

    Back to the text
  3. FP8 — A floating-point format that represents each value with 8 bits.

    Back to the text
  4. Checkpoint — A file containing saved model weights and related state. Versions or tasks in one model family may use different checkpoints.

    Back to the text
  5. Prompt — The input text sent to a model. For generative models it describes the desired result and strongly shapes the output.

    Back to the text
  6. Context window — The token span of input and generated content a model can handle in one request. The supported limit and memory use depend on the model and runtime settings.

    Back to the text
  7. KV cache — Memory that stores attention keys and values from earlier tokens for reuse during later token generation. Its size depends on context length and batch size.

    Back to the text
  8. Inference — The process of using a trained model to compute an output for an input. Here, local inference means running the model on the user’s device.

    Back to the text
  9. GPU — A processor designed to handle many calculations in parallel. It performs model computations during AI inference.

    Back to the text
  10. Runtime — The software environment that provides facilities needed while a program runs. In local AI, it can also refer to a model execution engine.

    Back to the text
  11. Tensor parallelism — A method that splits matrices and computations within a model layer across devices for joint execution. Devices communicate to combine partial results.

    Back to the text
  12. API — A defined interface that lets other code call a program’s functions.

    Back to the text
  13. Tool call — A structured request from a model for an external function such as reading a file, searching, or running a command. The agent runtime and its permission settings decide whether the request is actually executed.

    Back to the text
  14. Time to First Token — The time from sending a request until its first output token arrives.

    Back to the text
  15. Throughput — The amount of work processed or generated over time. Comparisons need the unit, such as tokens per second or requests per second.

    Back to the text

Frequently asked questions

What should you check first in this article?
Ling 3.1 Flash is an MoE language model with 560B total parameters and 25B active per token. Official SGLang recipes run its 574 GB FP8 checkpoint on 8×H200 or 4×GB300 servers.
How much memory does it need?
Context length is the maximum input a model can process at once. Longer documents also require more memory for the KV cache and inference engine. Check the available GPU memory and document length, then set the context to fit the task.
Where can you check the conditions and sources?
Ling 3.1 Flash generates answers from text prompts for coding and agent tasks. It has 560B total parameters, activates 25B per token, and supports up to a 1M-token context. The official FP8 checkpoint file listing totals about 574 GB. [Model card and files](https://huggingface.co/inclusionAI/Ling-3.1-flash/tree/main)