Executable programs and extensions
Last updated
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.

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.
| Server GPUs | Tensor / expert parallel | Runtime |
|---|---|---|
| 8×H200 | TP8 / EP8 | SGLang day-0 image |
| 4×GB300 | TP4 / EP4 | SGLang 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
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 30000When 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
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}'
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.
| Measure | Before | October 19 |
|---|---|---|
| Artificial Analysis index | 41 | 44 |
| AA-Briefcase (Elo) | 1400 | 1524 |
| AutomationBench | 62% | 68% |
| CritPt | 18% | 26% |
| SciCode | 54% | 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.

Terminology notes
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 textToken — A unit into which a model divides input or output for processing.
Back to the textFP8 — A floating-point format that represents each value with 8 bits.
Back to the textCheckpoint — A file containing saved model weights and related state. Versions or tasks in one model family may use different checkpoints.
Back to the textPrompt — The input text sent to a model. For generative models it describes the desired result and strongly shapes the output.
Back to the textContext 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 textKV 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 textInference — 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 textGPU — A processor designed to handle many calculations in parallel. It performs model computations during AI inference.
Back to the textRuntime — 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 textTensor 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 textAPI — A defined interface that lets other code call a program’s functions.
Back to the textTool 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 textTime to First Token — The time from sending a request until its first output token arrives.
Back to the textThroughput — 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)
Read next
Executable programs and extensions
Which local LLM app or serving engine should you start with?
Model setup recipes
Run a local LLM across Macs: MLX, JACCL and performance
Executable programs and extensions
How to Back Up and Restore a Local LLM You Already Use
Executable programs and extensions
What Is LiLiCorr? Speculative decoding for Bolt and Super VL
