Magistral Small: een gids met demoproject op vLLM en Ollama

Mistral heeft zijn eerste reasoning-model uitgebracht, Magistral, beschikbaar in twee varianten: Magistral Small (open-weights) en Magistral Medium (gesloten model).

In deze blog focus ik op Magistral Small, een open-weight reasoning-model ontworpen voor taken die gestructureerde logica, meertalige begrip en traceerbare uitleg vereisen. In combinatie met high-throughput inference-engines zoals vLLM of gebruiksvriendelijke tools zoals Ollama is het een uitstekend hulpmiddel voor het debuggen van gebrekkige logica en redeneertaken.

In deze tutorial laat ik stap voor stap zien hoe je:

• Magistral Small (24B) draait met vLLM en Ollama
• Een demoproject bouwt dat logica debugt met transparante, stapsgewijze redenatie

We houden onze lezers op de hoogte van het laatste AI-nieuws met The Median, onze gratis vrijdagse nieuwsbrief die de belangrijkste verhalen van de week samenvat. Abonneer je en blijf scherp in een paar minuten per week:

Wat is Mistrals Magistral?

Magistral is Mistral AI’s eerste dedicated reasoning-model, gebouwd voor stapsgewijze logica, meertalige nauwkeurigheid en traceerbare output. Het is een dubbele release met twee varianten:

• Magistral Small (24B): een volledig open-sourcemodel, beschikbaar onder Apache 2.0 en geschikt voor lokale deployment. 
• Magistral Medium: een krachtiger model op enterprise-niveau, beschikbaar via Mistral’s Le Chat, SageMaker en andere enterprise clouds.

Bron: Mistral

Magistral Small, het open model waarop we ons richten, ondersteunt een contextvenster van 128K (40K aanbevolen voor stabiele prestaties). Het is getraind met supervised fine-tuning op Magistral Medium-traces en reinforcement learning.

Magistral Small lokaal instellen en draaien met Ollama

In deze sectie voeren we lokaal inference uit op Mistral’s Magistral-model met behulp van Ollama. Let op: dit model vereist ongeveer 14 GB ruimte en past op een enkele RTX 4090 of een MacBook met 32 GB RAM zodra het is gekwantiseerd. Ik draaide deze demo op een M3 MacBook Pro.

Stap 1: Haal het model binnen via Ollama

Download Ollama voor macOS, Windows of Linux via: https://ollama.com/download.

Volg de installatie-instructies en controleer na installatie met deze terminalopdracht:

ollama --versionMogelijk gemaakt door

Haal vervolgens het Magistral-model binnen met het volgende commando:

ollama pull magistralMogelijk gemaakt door

Hiermee download je het Magistral-model naar je lokale machine. Let op: dit kan even duren, het model is ongeveer 14 GB.

Stap 2: Installeer dependencies

Laten we beginnen met het installeren van alle vereiste dependencies.

pip install ollama
pip install requestsMogelijk gemaakt door

Met de dependencies geïnstalleerd, zijn we klaar om inference te draaien.

Stap 3: Maak een gestructureerde prompttemplate

Nu zetten we een prompttemplatestructuur op (zoals genoemd in de originele Magistral-paper) die het denkproces van het model stuurt.

import gradio as gr
import requests
import json
def build_prompt(flawed_logic):
    return f"""<s>[SYSTEM_PROMPT]
A user will ask you to solve a task. You should first draft your thinking process (inner monologue) until you have derived the final answer. Afterwards, write a self-contained summary of your thoughts.
Your thinking process must follow the template below:
<think>
Your thoughts or/and draft, like working through an exercise on scratch paper. Be as casual and detailed as needed until you're confident.
</think>
Do not mention that you're debugging — just present your thought process and conclusion naturally.
[/SYSTEM_PROMPT][INST]
Here is a flawed solution. Can you debug it and correct it step by step?
\"\"\"{flawed_logic}\"\"\"
[/INST]
"""Mogelijk gemaakt door

De bovenstaande functie retourneert een geformatteerde prompt die Magistral aanstuurt om:

• Stap voor stap te redeneren met behulp van <think>...</think>-tags
• Een duidelijke conclusie te geven na de interne monoloog
• Eventuele verwijzingen naar “debuggen” te negeren voor een natuurlijke uitleg

Deze structuur is belangrijk voor modellen zoals Magistral die zijn getraind met tool-verrijkte prompts. Dezelfde system prompt-structuur kun je ook gebruiken voor zowel wiskundige als programmeerproblemen.

Stap 4: Stream inference en bouw de Gradio-UI

In deze stap streamen we de output van het Magistral-model in realtime via de lokale API van Ollama. Omdat we focussen op het debuggen van foutieve logica met traceerbare, stapsgewijze redenatie, is het belangrijk dat de gebruiker kan zien hoe het model tot conclusies komt. Tot slot tonen we de uitleg in een overzichtelijke Gradio-interface.

def call_ollama_stream(flawed_logic):
    prompt = build_prompt(flawed_logic)
    response_text = ""
    with requests.post(
        "http://localhost:11434/api/generate",
        json={"model": "magistral", "prompt": prompt, "stream": True},
        stream=True,
    ) as r:
        for line in r.iter_lines():
            if line:
                content = json.loads(line).get("response", "")
                response_text += content
    return response_text
with gr.Blocks(theme=gr.themes.Base()) as demo:
    gr.Markdown("## Chain-of-Logic Debugger (Magistral + Ollama)")
    gr.Markdown("Paste a flawed logical argument or math proof, and Magistral will debug it with step-by-step reasoning.")
    with gr.Row():
        input_box = gr.Textbox(lines=8, label="Flawed Logic / Proof")
        output_box = gr.Textbox(lines=15, label="Debugged Explanation")  
    debug_button = gr.Button("Run Debugger")
    debug_button.click(fn=call_ollama_stream, inputs=input_box, outputs=output_box)
demo.launch(debug = True, share=True)Mogelijk gemaakt door

Hier is in grote lijnen wat er gebeurt:

• We beginnen met een herbruikbare functie build_prompt() die de gebruikersinput verpakt in een gestructureerde prompt die het model stuurt met <think>-redenatietags.
• Wanneer de gebruiker een foutief bewijs of een logische uitspraak indient, stuurt de functie call_ollama_stream() de prompt naar de HTTP-API van Ollama op localhost:11434 via een streaming POST-request.
• De functie luistert regel voor regel naar gestreamde responses met requests.iter_lines(). Voor elke ontvangen regel haalt hij het response-veld uit de JSON-payload en voegt dat toe aan een doorlopend tekstbuffer.
• Zodra alle gestreamde regels zijn verzameld, wordt de volledige modelrespons geretourneerd en getoond in de Gradio-UI.

Dit was mijn input:

Assume x = y. Then, x² = xy. Subtracting both sides gives x² - y² = xy - y². So, (x+y)(x−y) = y(x−y). Cancelling x−y gives x+y = y. But since x = y, this means 2y = y → 2 = 1.Mogelijk gemaakt door

In mijn tests op een M3 MacBook Pro ging het model behoorlijk goed om met eenvoudige redeneerketens en wiskundige bewijzen. Voor diepere redeneertaken of langere gedachteketens miste het af en toe randgevallen, wat te verwachten is van een open model van 24B. Deze aanpak is ideaal voor lichte reasoning-demo’s of on-device chain-of-thought-toepassingen, zonder afhankelijk te zijn van cloud-API’s.

Magistral Small draaien met vLLM

In deze sectie leg ik uit hoe je een krachtige GPU-instance op RunPod voorziet, Mistral’s Magistral-model deployt met vLLM en een OpenAI-compatibele API blootstelt voor zowel lokale als remote inference.

Stap 1: Stel je RunPod-omgeving in 

Zorg dat je RunPod-account is ingesteld voordat je het model start:

• Log in op RunPod.io en configureer je facturering.
• Voeg minstens $10 toe aan je saldo, zodat je een enkele A100 GPU-instance kunt draaien voor de duur van dit project.

Stap 2: Deploy een pod met een A100 GPU

Laten we nu een pod provisioneren die het model kan hosten. Volg deze stappen om een pod op te zetten:

• Ga naar de sectie Pods en selecteer A100 SXM GPU met 80GB VRAM. Voor dit project gebruiken we slechts één A100 GPU.

• Ga naar “Deploy a Pod” en klik op Edit Template.

• Verhoog nu de containerdisk en volumedisk naar 60 GB en klik op Set Overrides.

• Klik daarna op Deploy On-Demand, en je pod wordt gedeployed. De gedeployde pod verschijnt onder de pods-sectie met alle ingestelde configuraties. Wacht een paar seconden totdat de knop Connect actief wordt.

Stap 3: Verbind met je pod

Zodra de knop Connect klikbaar wordt, klik je erop. Je ziet meerdere verbindingsopties—je kunt ofwel:

• Een JupyterLab-terminal openen om shellcommando’s of een Jupyternotebook te draaien (aanbevolen).
• Of SSH- of HTTP-poorten gebruiken als je remote controle wilt.

Let op: Wacht tot je een groen bolletje 🟢 met Ready ziet onder Jupyter Lab.

Klik op Jupyter Lab—dit brengt je naar een nieuw venster met opties om een nieuwe Jupyternotebook te maken. Open een nieuwe terminal of maak een nieuw Python-bestand aan.

Stap 4: Installeer vLLM en de vereiste libraries

Installeer vLLM en zijn dependencies in de terminal of Jupyter Notebook binnen je pod. 

pip install -U vllm --pre --extra-index-url https://wheels.vllm.ai/nightly
pip install gradioMogelijk gemaakt door

Controleer ook dat je mistral_common >= 1.6.0 draait door:

python -c "import mistral_common; print(mistral_common.__version__)"Mogelijk gemaakt door

Stap 5: Serve het model

Laten we nu het model serven. Klik op het “+”-teken linksboven en selecteer terminal uit de opties, voer daarna het volgende commando uit:

vllm serve mistralai/Magistral-Small-2506 \
  --tokenizer_mode mistral \
  --config_format mistral \
  --load_format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choiceMogelijk gemaakt door

Laat deze terminal actief, want dit commando start het Magistral Small model met vLLM en stelt het beschikbaar op een snelle, OpenAI-compatibele API-endpoint (http://localhost:8000/v1). Dit doen de flags:

Stap 6: Foutieve logica debuggen met Magistral en vLLM

We bouwen nu een demo waarin Magistral wordt gevraagd om een foutieve logica of wiskundig bewijs te debuggen. Het model geeft een gedetailleerde innerlijke monoloog binnen <think>-tags en een eindsamenvatting.

Stap 6.1: Initialiseer de OpenAI-client en system prompt

We beginnen met de imports en initialiseren de OpenAI-client in Jupyter Notebook. Vervolgens stellen we de system prompt van Magistral in, zoals voorgesteld in de originele Magistral-paper.

import gradio as gr
from openai import OpenAI
import re
import time
client = OpenAI(api_key="EMPTY", base_url="http://localhost:8000/v1")
SYSTEM_PROMPT = """<s>[SYSTEM_PROMPT]system_prompt
A user will ask you to solve a task. You should first draft your thinking process (inner monologue) until you have derived the final answer. Afterwards, write a self-contained summary of your thoughts.
<think>
Your thoughts or draft, like working through an exercise on scratch paper.
</think>
Here, provide a concise summary that reflects your reasoning and presents a clear final answer to the user.
Problem:
[/SYSTEM_PROMPT]"""Mogelijk gemaakt door

De SYSTEM_PROMPT definieert het gestructureerde format voor hoe het model moet antwoorden:

• Het model wordt gevraagd eerst een <think>-trace te genereren (als een innerlijke monoloog),
• en daarna een eindsamenvatting te produceren na de </think>-tag.

Stap 6.2: Modeloutput streamen en onderbrekingen toestaan

Vervolgens streamen we de modeloutput door de vereiste temperature, top_p en max_tokens in te stellen zoals voorgesteld in de originele Magistral-blog.

# Streaming logic with stop control
def debug_faulty_logic_stream(faulty_proof, stop_signal):
    stop_signal["stop"] = False 
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": f"Here is a flawed logic or math proof. Can you debug it step-by-step?\n\n{faulty_proof}"}
    ]
    try:
        response = client.chat.completions.create(
            model="mistralai/Magistral-Small-2506",
            messages=messages,
            stream=True,
            temperature=0.7,
            top_p=0.95,
            max_tokens=2048
        )
        buffer = ""
        for chunk in response:
            if stop_signal.get("stop"):
                break
            delta = chunk.choices[0].delta
            if hasattr(delta, "content") and delta.content:
                buffer += delta.content
                filtered = re.sub(r"<think>.*?</think>", "", buffer, flags=re.DOTALL).strip()
                yield filtered
            time.sleep(0.02)
    except Exception as e:
        yield f"Error: {str(e)}"
# Set stop flag when stop button is clicked
def stop_streaming(stop_signal):
    stop_signal["stop"] = True
    return gr.Textbox.update(value="Stopped.")Mogelijk gemaakt door

De bovenstaande code verzorgt live token-voor-token outputstreaming van het model. Met stop_signal kunnen gebruikers de stream onderbreken door op een “Stop”-knop te klikken.

Terwijl de buffer alle content verzamelt, wordt alleen de samenvatting (zonder de <think>-tag) doorgestuurd met behulp van een reguliere expressie. Als er een fout optreedt (bijv. netwerkprobleem), wordt het foutbericht teruggegeven.

Stap 6.3: Bouw de Gradio-UI

Laten we dit samenbrengen met een eenvoudige Gradio-app waarmee gebruikers hun foutieve logica of bewijs kunnen invoeren en aan het model kunnen aanbieden voor redenering.

with gr.Blocks() as demo:
    gr.Markdown("## Chain-of-Logic Debugger (Streaming via Magistral + vLLM)")

    input_box = gr.Textbox(
        label="Paste Your Faulty Logic or Proof",
        lines=8,
        placeholder="e.g., Assume x = y, then x² = xy..."
    )
    output_box = gr.Textbox(label="Corrected Reasoning (Streaming Output)")

    submit_btn = gr.Button("Submit")
    stop_btn = gr.Button("Stop")

    stop_flag = gr.State({"stop": False})

    submit_btn.click(
        fn=debug_faulty_logic_stream,
        inputs=[input_box, stop_flag], 
        outputs=output_box
    )

    stop_btn.click(
        fn=stop_streaming,
        inputs=stop_flag,
        outputs=output_box
    )

if __name__ == "__main__":
    demo.launch(share=True, inbrowser=True, debug=True)Mogelijk gemaakt door

De bovenstaande code maakt een eenvoudige Gradio-interface met:

• Een tekstinvoerveld waarin gebruikers foutieve logica kunnen plakken.
• Een live uitvoerveld dat wordt bijgewerkt terwijl tokens binnenstromen.
• Een Submit-knop om de debugger te starten, en een Stop-knop om deze te stoppen.

Er wordt gebruikgemaakt van gr.State om bij te houden of de gebruiker het streamingproces wil onderbreken. Daarna draait de methode launch() de app lokaal en opent deze in je browser. Dit was mijn input:

Assume x = y. Then, x² = xy. Subtracting both sides gives x² - y² = xy - y². So, (x+y)(x−y) = y(x−y). Cancelling x−y gives x+y = y. But since x = y, this means 2y = y → 2 = 1.Mogelijk gemaakt door

Je kunt overschakelen naar de al draaiende terminal waar vLLM serveert om logs van het KV-cachegebruik te bekijken, evenals de hit rate die stijgt wanneer het model output terugstuurt.

In vergelijking met Ollama was vLLM merkbaar sneller en stabieler tijdens inference. De streaming voelde soepel aan en de outputs waren meestal goed gestructureerd. Het model herhaalde soms gedachten binnen <think>-secties, waarschijnlijk door de aard van autoregressieve decodering zonder samplingstraffen.

Ollama vs. vLLM voor het draaien van Magistral Small 

Hoewel Ollama een gequantiseerde 4-bitversie van het model ondersteunt voor efficiënte on-device inference, vereist vLLM GPU-acceleratie, wat het iets duurder maakt (ongeveer $5 voor dit project). Het 4-bit gequantiseerde Magistral-model vereist ongeveer 14 GB geheugen en kan worden gehost op een enkele RTX 4090 GPU of zelfs een MacBook met 32 GB RAM. Inference kan echter traag zijn, tot 4 minuten per response door beperkte rekenkracht.

Daarentegen biedt vLLM aanzienlijk snellere inference (meestal minder dan een minuut per response) wanneer het wordt gedeployed op high-performance GPU’s zoals de A100 SXM, waardoor het geschikter is voor responsieve apps of schaalbare deployments.

Als je alleen experimenteert en lokale resources hebt, is Ollama ideaal vanwege de lage instap. Maar voor performance op productieniveau of grotere workloads is vLLM de aanbevolen keuze. Houd er rekening mee dat vLLM lokaal kan draaien, maar nog steeds een capabele GPU vereist.

Conclusie

In deze tutorial hebben we Magistral Small—een reasoning-first LLM van Mistral—gebruikt om een stapsgewijze logic debugger te bouwen. We hebben het model lokaal gedeployed met zowel Ollama voor snelle on-device tests als vLLM voor high-throughput GPU-inference met OpenAI-compatibele API’s. We hebben de redeneercapaciteiten van het model ook getest met een Gradio-applicatie. Of je nu foutieve logica debugt of reasoning-AI-tools bouwt, Magistral Small kan een goede oplossing zijn.