mistralai/Mistral-Large-4-1T-A52B · Hugging Face

Source: https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#mistral-large-4—le-chonkMistral Large 4 - Le Chonk

Mistral Large 4 is our largest and most capable model to date: a 1 trillion-parameter natively multimodal Mixture-of-Experts model with 49 billion active parameters per token (52 billion including embeddings and output layers), trained from scratch on 3,800 NVIDIA Grace Blackwell GPUs in Mistral’s own datacenters in Europe.

Mistral Large 4 unifies instruction following, reasoning, coding, and agentic workflows in a single set of weights. While a generalist model, it shows especially good performance on workloads such as cybersecurity, finance, and law, and it surpasses frontier closed models on visual grounding. It is natively fluent in 160+ languages, including every official language of the European Union.

Find more information on ourblog. The model is also served on theMistral APIasmistral\-large\-4.

The checkpoint ships with an embedded DSpark speculative decoding draft head — seeSpeculative decoding (DSpark).

A quantizedNVFP4 checkpointis also available, with a smaller memory footprint, faster inference and same performance. It targets Blackwell GPUs and supports vLLM and SGLang.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#key-featuresKey Features

Mistral Large 4 includes the following architectural choices:

• ~1T total / ~52B active parameters: granular Mixture-of-Experts with 128 routed experts (4 active per token) and 1 shared expert.
• 1M context length, for long-context workloads.
• Multimodal input: accepts text and image input, with text output. Pixtral-style vision encoder trained to handle variable image sizes and aspect ratios.
• Instruct and Reasoning functionalitieswith function calls, reasoning effort configurable per request.

Mistral Large 4 offers the following capabilities:

• Reasoning Mode: three reasoning efforts —low,medium,high(default) — so the same model can answer a quick chat reply or work through a complex agentic run.
• Vision: analyzes images, charts, technical drawings, and documents, with state-of-the-art visual grounding among open weights.
• Multilingual: natively fluent in 160+ languages, including all official languages of the European Union.
• System Prompt: strong adherence and support for system prompts.
• Agentic: native function calling, JSON output, and strict JSON schema enforcement.
• Cybersecurity: state of the art among open-weight models for security work, while refusing malicious requests.
• Large Context Window: supports a 1M context window.

We release this model under theMistral Ecosystem Open-Weight License: a modified version of the MIT license, for both commercial and non-commercial use — operating a Model-as-a-Service business requires a separate commercial license with Mistral.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#recommended-settingsRecommended Settings

• Reasoning Effort:- 'low'/'medium'/'high'— default is'high'. - Usereasoning\_effort="high"for complex prompts and agentic usage,'low'for fast chat replies and'medium'for day to day usage.
• Sampling: for all reasoning efforts, we recommend the following sampling parameters:- temperature=1\.0 - top\_p=0\.95
• System Prompt: define a clear environment and use case, including guidance on how to effectively leverage tools in agentic systems.
• Tools: keep the set of tools well-defined and limit their number to the minimum required for the use case.
• Context: the checkpoint supports a 1M context window.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#benchmarksBenchmarks

We compared Mistral Large 4 with recent open-weight models. We report results on agentic coding and global intelligence here; for more benchmarks, especially on cybersecurity, finance and law, see ourblog post.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#agentic-codingAgentic Coding

Mistral Large 4 delivers frontier coding performance with significantly fewer tokens, making sophisticated coding agents more economical to run at scale.

On the Artificial Analysis Coding Agent Index, ML4 scores48%, effectively tied with the leading open-weight model, GLM-5.3, while using**47%**fewer tokens per task on average.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#global-intelligenceGlobal Intelligence

On the Artificial Analysis Intelligence Index v5, Mistral Large 4 scores26, the highest among western open-weight models. The leading open-weight models from China score higher on this aggregate index, but Mistral Large 4 is particularly strong on coding and cybersecurity, as shown in ourblog post.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#demo-galleryDemo Gallery

Le Chonk Galleryis a live gallery of demo Spaces built with Mistral Large 4, from us and from the community: coding, vision and grounding, tool calls, JSON schema, multilingual, and more. Any Space taggedLe\_chonkappears there.

Official demos run on the Mistral API with a small shared free budget per visitor for the first week of the release, so you can try the model without paying. You can also use your own Mistral API key.

To build a demo, we recommendMistral Vibe, our coding agent powered by Mistral Large 4.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#usageUsage

You can find Mistral Large 4 support on multiple libraries for inference and fine-tuning.

Wethankall the ecosystem folks who helped us throughout this release to integrate Le Chonk into their frameworks.

The model can be deployed with:

• vllm \(recommended\): SeehereorvLLM’s recipes.
• SGLang: Seehereor SGLang’scookbook.
• transformers: SeehereorHugging Face’s blog post.
• llama\.cpp: See GGUFs and instructionshere.

Fine-tune the model via:

• Axolotl: Seehere.
• Unsloth: Seeherefor a guide andherefor their GGUFs.
• TRL: Seehere.

For optimal performance, we recommend using the Mistral AI API if local serving is subpar.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#vllm-recommendedvLLM (Recommended)

We recommend using Mistral Large 4 with thevLLM libraryfor production-ready inference.

See also thevLLM recipe for Mistral Large 4for ready-made serving configurations.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#installationInstallation

Use the official vLLM Docker image, which includes support for Mistral Large 4:

docker pull vllm/vllm-openai:mistral-large-4

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#serve-the-modelServe the Model

We recommend a server/client setup:

docker run --runtime nvidia --gpus all \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:mistral-large-4 \
  --model mistralai/Mistral-Large-4-1T-A52B \
  --tensor-parallel-size 8 \
  --tool-call-parser mistral \
  --reasoning-parser mistral \
  --enable-auto-tool-choice \
  --gpu-memory-utilization 0.85

Key parameter notes:

• \-\-tool\-call\-parser mistraland\-\-reasoning\-parser mistral: required for tool usage and to separate reasoning from content in responses.
• If you run short of GPU memory, lower\-\-max\-model\-lenand/or\-\-max\-num\-seqs(concurrency). See thevLLM guide on conserving memory.

https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#ping-the-serverPing the Server

max\_completion\_tokensincludes reasoning tokens as well as visible output tokens.

Instruction Following``` from openai import OpenAI

Modify OpenAI’s API key and API base to use vLLM’s API server.

openai_api_key = “EMPTY” openai_api_base = “http://localhost:8000/v1”

client = OpenAI( api_key=openai_api_key, base_url=openai_api_base, )

model = client.models.list().data[0].id

response = client.chat.completions.create( model=model, messages=[ { “role”: “user”, “content”: “Write me a sentence where every word starts with the next letter in the alphabet - start with ‘a’ and end with ‘z’.”, } ], reasoning_effort=“low”, # Increase with ‘medium’ or ‘high’. temperature=1.0, top_p=0.95, max_completion_tokens=4096, )

print(“REASONING”) print(“~~~~~~~~~”) print(response.choices[0].message.reasoning) print(“CONTENT”) print(“~~~~~~~”) print(response.choices[0].message.content)

Strict JSON SchemaMistral Large 4 enforces response formats natively, including strict JSON schemas\.

from openai import OpenAI

Modify OpenAI’s API key and API base to use vLLM’s API server.

openai_api_key = “EMPTY” openai_api_base = “http://localhost:8000/v1”

client = OpenAI( api_key=openai_api_key, base_url=openai_api_base, )

model = client.models.list().data[0].id

response = client.chat.completions.create( model=model, messages=[ {“role”: “user”, “content”: “What is 1 + 1? Answer as JSON.”} ], reasoning_effort=“medium”, temperature=1.0, top_p=0.95, response_format={ “type”: “json_schema”, “json_schema”: { “name”: “arithmetic_answer”, “strict”: True, “schema”: { “type”: “object”, “properties”: {“answer”: {“type”: “string”}}, “required”: [“answer”], “additionalProperties”: False, }, }, }, max_completion_tokens=16384, )

print(response.choices[0].message.content)

Vision and Tool CallLet's solve some equations thanks to our simple Python calculator tool\.

import json

from openai import OpenAI

Modify OpenAI’s API key and API base to use vLLM’s API server.

openai_api_key = “EMPTY” openai_api_base = “http://localhost:8000/v1”

client = OpenAI( api_key=openai_api_key, base_url=openai_api_base, )

model = client.models.list().data[0].id

image_url = “https://math-coaching.com/img/fiche/46/expressions-mathematiques.jpg”

def my_calculator(expression: str) -> str: return str(eval(expression))

tools = [ { “type”: “function”, “function”: { “name”: “my_calculator”, “description”: “A calculator that can evaluate a mathematical expression.”, “parameters”: { “type”: “object”, “properties”: { “expression”: { “type”: “string”, “description”: “The mathematical expression to evaluate.”, }, }, “required”: [“expression”], }, }, } ]

messages = [ { “role”: “user”, “content”: [ { “type”: “text”, “text”: “Thanks to your calculator, compute the results for the equations that involve numbers displayed in the image.”, }, {“type”: “image_url”, “image_url”: {“url”: image_url}}, ], } ]

response = client.chat.completions.create( model=model, messages=messages, tools=tools, tool_choice=“auto”, reasoning_effort=“high”, temperature=1.0, top_p=0.95, )

tool_calls = response.choices[0].message.tool_calls

results = [] for tool_call in tool_calls: function_name = tool_call.function.name function_args = tool_call.function.arguments if function_name == “my_calculator”: result = my_calculator(**json.loads(function_args)) results.append(result)

messages.append({“role”: “assistant”, “tool_calls”: tool_calls}) for tool_call, result in zip(tool_calls, results): messages.append( { “role”: “tool”, “tool_call_id”: tool_call.id, “name”: tool_call.function.name, “content”: result, } )

response = client.chat.completions.create( model=model, messages=messages, reasoning_effort=“high”, temperature=1.0, top_p=0.95, )

print(“REASONING”) print(“~~~~~~~~~”) print(response.choices[0].message.reasoning) print(“CONTENT”) print(“~~~~~~~”) print(response.choices[0].message.content)

### [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#speculative-decoding-dspark](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#speculative-decoding-dspark)Speculative decoding \(DSpark\)

The checkpoint ships a DSpark draft head next to the target weights: 3 dense MLA draft layers in BF16 that propose a block of 3 tokens with a recurrent Markov head\.

To enable it, add the following argument to the serving command above:

–speculative-config ‘{“method”: “dspark”, “num_speculative_tokens”: 3}’

`num\_speculative\_tokens`is set to 3, the depth of the draft block\.

DSpark speeds up decoding without changing the target model's outputs: we measured up to**1\.9x**higher throughput than serving the target model alone\. Actual gains depend on hardware and workload\.

## [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#sglang](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#sglang)SGLang

Serve Mistral Large 4 with the[SGLang library](https://github.com/sgl-project/sglang)for production\-ready inference\. See also SGLang's[cookbook](https://docs.sglang.io/cookbook/autoregressive/Mistral/Mistral-Large-4)\.

### [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#installation-1](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#installation-1)Installation

Use the official SGLang Docker image, which includes support for Mistral Large 4:

docker pull lmsysorg/sglang:mistral-large-4

### [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#serve-the-model-1](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#serve-the-model-1)Serve the Model

sglang serve
–model-path mistralai/Mistral-Large-4-1T-A52B
–tp-size 8
–mem-fraction-static 0.85
–speculative-algorithm DSPARK
–max-running-requests 64
–reasoning-parser auto
–tool-call-parser auto
–host 0.0.0.0
–port 30000

> Speculative decoding \(DSpark\) is on and this recipe pins`\-\-max\-running\-requests`to**64**\. Adjust it to match your target concurrency — if you remove the flag, SGLang falls back to**48**\.

Key parameter notes:

- `\-\-speculative\-algorithm DSPARK`: enables the embedded DSpark draft head, which proposes blocks of 3 tokens\. Remove this flag to serve without speculation\.
- `\-\-tp\-size 8`: example tensor\-parallel size for a node of 8 GPUs; adjust to your topology\.
- `\-\-reasoning\-parser auto`and`\-\-tool\-call\-parser auto`: let SGLang pick the reasoning and tool\-call parsers for this model\.

## [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#transformers](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#transformers)Transformers

For more details, check[Hugging Face’s blog post](https://huggingface.co/blog/mistral-large4)\.

Install Transformers from`main`:

uv pip install git+https://github.com/huggingface/transformers

Python Inference SnippetSave the following as`script\.py`:

import os from transformers import AutoProcessor, AutoModelForMultimodalLM, DistributedConfig

distributed_config = DistributedConfig( tp_size=int(os.environ[“WORLD_SIZE”]), ep_size=int(os.environ[“WORLD_SIZE”]), )

model_id = “mistralai/Mistral-Large-4-1T-A52B” processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForMultimodalLM.from_pretrained( model_id, distributed_config=distributed_config, dtype=“auto”, )

only text

text_messages = [ { “role”: “user”, “content”: “Who are you?” } ]

text + image

messages = [ { “role”: “user”, “content”: [ { “type”: “image”, “image”: “https://huggingface.co/datasets/huggingface/cats-image/resolve/main/cats_image.jpeg”, }, { “type”: “text”, “text”: “How many cats are in the image?”, }, ], }, ]

inputs = processor.apply_chat_template( messages, # text_messages add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors=“pt”, reasoning_effort=“medium”, # low, medium, high ).to(model.device).to(model.dtype) input_len = inputs[“input_ids”].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=100) if int(os.environ[“RANK”]) == 0: print(processor.decode(outputs[0][input_len:], skip_special_tokens=False))

Then run it on 8 GPUs with`torchrun`:

torchrun –nproc-per-node 8 script.py

## [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#mistral-vibe](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#mistral-vibe)Mistral\-Vibe

Use Mistral Large 4 with[Mistral Vibe](https://github.com/mistralai/mistral-vibe), our open\-source CLI coding assistant\.

### [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#installation-2](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#installation-2)Installation

Install Vibe with the one\-line installer \(Linux and macOS\):

curl -LsSf https://mistral.ai/vibe/install.sh | bash

Or with`uv`or`pip`:

uv tool install mistral-vibe

or

pip install mistral-vibe

Then run`vibe`in your project\. On first launch it asks for your Mistral API key and saves it to`~/\.vibe/\.env`\. To use Mistral Large 4 through the Mistral API, select`mistral\-large\-4`as the model\.

### [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#local-server](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#local-server)Local server

To use a local vLLM server instead, add this to`~/\.vibe/config\.toml`:

display_name = “Mistral Large 4 (local vLLM)” description = “Mistral Large 4 mode using local vLLM” safety = “neutral”

active_model = “mistral-large-4” # Make sure this is the only active_model entry [[providers]] name = “vllm” api_base = “http://:8000/v1” api_key_env_var = “” backend = “generic” api_style = “reasoning”

[[models]] name = “mistralai/Mistral-Large-4-1T-A52B” provider = “vllm” alias = “mistral-large-4” thinking = “high” thinking_levels = [“low”, “medium”, “high”] temperature = 1.0 supports_images = true max_context_length = 1048576 auto_compact_threshold = 800000

[tools.bash] default_timeout = 1200

**Notes**:

- Replace`<your\-host\-url\>`with your server's URL\.
- Other inference backends are also supported\. Please look at[Mistral Vibe repo](https://github.com/mistralai/mistral-vibe)for more info\.

## [https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#license](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B#license)License

This model is licensed under the[Mistral Ecosystem Open\-Weight License](https://huggingface.co/mistralai/Mistral-Large-4-1T-A52B/blob/main/LICENSE)\.

*You must not use this model in a manner that infringes, misappropriates, or otherwise violates any third party’s rights, including intellectual property rights\.*