---
title: "magistral-small-2506"
publisher: "mistralai"
type: "endpoint"
updated: "2025-07-10T22:33:57.614Z"
description: "High performance reasoning model optimized for efficiency and edge deployment"
canonical: "https://build.nvidia.com/mistralai/magistral-small-2506"
---

# Magistral-Small-2506 Overview
## Description
Magistral-Small-2506 is a lightweight, general-purpose language model that generates and understands natural language for tasks like Q&A, summarization, and instruction following. Designed for efficiency, it balances performance with low computational overhead, making it suitable for real-world applications. Building upon Mistral Small 3.1 (2503), **with added reasoning capabilities**, undergoing SFT from Magistral Medium traces and RL on top, it's a small, efficient reasoning model with 24B parameters.

Magistral Small can be deployed locally, fitting within a single RTX 4090 or a 32GB RAM MacBook once quantized.

This model is for research and development only.

Learn more about Magistral in our [blog post](https://mistral.ai/news/magistral/).  
The model was presented in the paper [Magistral](https://huggingface.co/papers/2506.10910).
* **Supported Languages:** Supports dozens of languages, including English, French, German, Greek, Hindi, Indonesian, Italian, Japanese, Korean, Malay, Nepali, Polish, Portuguese, Romanian, Russian, Serbian, Spanish, Turkish, Ukrainian, Vietnamese, Arabic, Bengali, Chinese, and Farsi

### Key Features
- **Reasoning:** Capable of long chains of reasoning traces before providing an answer.
- **Multilingual:** Supports dozens of languages, including English, French, German, Greek, Hindi, Indonesian, Italian, Japanese, Korean, Malay, Nepali, Polish, Portuguese, Romanian, Russian, Serbian, Spanish, Turkish, Ukrainian, Vietnamese, Arabic, Bengali, Chinese, and Farsi.

- **Context Window:** A 128k context window, **but** performance might degrade past **40k**. Hence we recommend setting the maximum model length to 40k.

## Third-Party Community Consideration
This model is not owned or developed by NVIDIA. This model has been developed and built to a third-party's requirements for this application and use case; see link to Non-NVIDIA [MistralAi/Magistral-Small-2506](https://huggingface.co/mistralai/Magistral-Small-2506).

### License/Terms of Use
**GOVERNING TERMS:**  This trial service is governed by the [NVIDIA API Trial Terms of Service](https://assets.ngc.nvidia.com/products/api-catalog/legal/NVIDIA%20API%20Trial%20Terms%20of%20Service.pdf). Use of this model is governed by the [NVIDIA Community Model License](https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-community-models-license/). Additional Information: [Apache 2.0](https://huggingface.co/datasets/choosealicense/licenses/blob/main/markdown/apache-2.0.md).

### Deployment Geography
Global

### Use Case
Magistral Small is a reasoning model with multilingual capabilities that can be deployed locally, fitting within a single RTX 4090.

### Release Date
**Build.NVIDIA.com:** 2024-07-09 via [link](https://build.nvidia.com/mistralai/magistral-small-2506)  
**Hugging Face:** 2024-06-25 [link](https://huggingface.co/mistralai/Magistral-Small-2506)

### Reference(s)
Technical Paper: [Magistral](https://huggingface.co/papers/2506.10910)

## Model Architecture

Architecture Type: Decoder-only (Transformer-based)

Network Architecture: Transformer-based, decoder-only architecture with rotary positional embeddings, multi-head self-attention, and long-context support (up to 128k tokens). Based on Mistral open-weight foundation models.

## Model Architecture: <br>
* Architecture Type: Transformer decoder <br>
* Network Architecture: Transformer with FlashAttention <br>
* Parameter Count: 24B <br>
* Base Model: [Mistral-Small-3.1-24B-Base-2503](https://huggingface.co/mistralai/Mistral-Small-3.1-24B-Base-2503) <br>

## Input
**Input Type(s):** Text <br>
**Input Format(s):** String <br>
**Input Parameters:** One-Dimensional (1D) <br>
**Other Properties Related to Input:** Context Length: 128k <br>

## Output
**Output Type(s)**: Text <br>
**Output Format(s)**: String <br>
**Output Parameters**: One-Dimensional (1D) <br>
**Other Properties Related to Output:** Max theoretical context length: 128,000 tokens, Practical limit: ≈ 40k tokens (40960) <br>

Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.**

## Software Integration
Runtime Engine: vLLM  

### Supported Hardware Microarchitecture Compatibility
* NVIDIA Ampere
* NVIDIA Blackwell
* NVIDIA Hopper
* NVIDIA Lovelace 

### Preferred Operating System(s)
Linux

### Model Version(s)
Magistral-Small-2506 1.0

## Training, Testing, and Evaluation Datasets

### Training Dataset

* **Data Collection Method by dataset:** Hybrid: Automated, Human
* **Labeling Method by dataset:** Hybrid: Automated, Human 
* **Properties:** Trained on ~2 trillion tokens from web, books, code, and conversations; no sensors used (not applicable for text-based data).

### Testing Dataset

* **Data Collection Method by dataset:** Hybrid: Automated, Human
* **Labeling Method by dataset:** Hybrid: Automated, Human 
* **Properties:** Undisclosed

### Evaluation Dataset
* **Data Collection Method by dataset:** Hybrid: Automated, Human  

* **Labeling Method by dataset:** Hybrid: Automated, Human
* **Properties:** The benchmarks noted in the following session were used for evaluation.

#### Benchmark Results

| Model | AIME24 pass@1 | AIME25 pass@1 | GPQA Diamond | Livecodebench (v5) |
|-------|-------------|-------------|--------------|-------------------|
| Magistral Medium | 73.59% | 64.95% | 70.83% | 59.36% |
| Magistral Small | 70.68% | 62.76% | 68.18% | 55.84% |

### Inference
Acceleration Engine: vLLM  
Test Hardware: 
* L40s x2  

## Ethical Considerations
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.  

Please report security vulnerabilities or NVIDIA AI Concerns [here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/).

## Prototype

```python
from openai import OpenAI

client = OpenAI(
base_url = "https://integrate.api.nvidia.com/v1",
api_key = "$NVIDIA_API_KEY"
)

completion = client.chat.completions.create(
model="",
messages=[{"role":"user","content":""}],
temperature=,
top_p=,
max_tokens=,
stream=NaN
)

reasoning = getattr(completion.choices[0].message, "reasoning_content", None)
if reasoning:
print(reasoning)
print(completion.choices[0].message.content)
```

```python
from langchain_nvidia_ai_endpoints import ChatNVIDIA

client = ChatNVIDIA(
model="",
api_key="$NVIDIA_API_KEY", 
temperature=,
top_p=,
max_tokens=,
)

response = client.invoke([{"role":"user","content":""}])
if response.additional_kwargs and "reasoning_content" in response.additional_kwargs:
print(response.additional_kwargs["reasoning_content"])
print(response.content)
```

```javascript
import OpenAI from 'openai';

const openai = new OpenAI({
apiKey: '$NVIDIA_API_KEY',
baseURL: 'https://integrate.api.nvidia.com/v1',
})

async function main() {
const completion = await openai.chat.completions.create({
model: "",
messages: [{"role":"user","content":""}],
temperature: ,
top_p: ,
max_tokens: ,
stream: 
})

const reasoning = completion.choices[0]?.message?.reasoning_content;
if (reasoning) process.stdout.write(reasoning + "\n");
process.stdout.write(completion.choices[0]?.message?.content);

}

main();
```

```bash
invoke_url='https://integrate.api.nvidia.com/v1/chat/completions'

authorization_header='Authorization: Bearer '
accept_header='Accept: application/json'
content_type_header='Content-Type: application/json'

data=$'{
"messages": [
{
"role": "user",
"content": ""
}
]
}'

response=$(curl --silent -i -w "\n%{http_code}" --request POST \
--url "$invoke_url" \
--header "$authorization_header" \
--header "$accept_header" \
--header "$content_type_header" \
--data "$data"
)

echo "$response"
```