Magistral Small: Panduan dengan Proyek Demo di vLLM dan Ollama

Mistral telah merilis model penalaran pertamanya, Magistral, yang tersedia dalam dua varian: Magistral Small (bobot terbuka) dan Magistral Medium (model tertutup).

Fokus saya di blog ini adalah pada Magistral Small, model penalaran berbobot terbuka yang dirancang untuk tugas yang memerlukan logika terstruktur, pemahaman multibahasa, dan kemampuan memberikan penjelasan yang dapat ditelusuri. Saat dipasangkan dengan mesin inferensi ber-throughput tinggi seperti vLLM atau alat yang mudah digunakan seperti Ollama, model ini menjadi alat yang hebat untuk men-debug logika yang cacat dan tugas penalaran.

Dalam tutorial ini, saya akan menjelaskan langkah demi langkah cara:

• Menjalankan Magistral Small (24B) dengan vLLM dan Ollama
• Membangun proyek demo yang men-debug logika dengan penalaran transparan langkah demi langkah

Kami terus memperbarui pembaca tentang kabar terbaru AI melalui The Median, buletin Jumat gratis kami yang merangkum kisah-kisah kunci pekan ini. Berlangganan dan tetap tajam hanya dalam beberapa menit per minggu:

Apa Itu Magistral dari Mistral?

Magistral adalah model penalaran khusus pertama dari Mistral AI, dibangun untuk logika langkah demi langkah, akurasi multibahasa, dan keluaran yang dapat ditelusuri. Ini adalah rilis ganda yang hadir dalam dua varian:

• Magistral Small (24B): Model sepenuhnya sumber terbuka, tersedia di bawah Apache 2.0 dan cocok untuk deployment lokal. 
• Magistral Medium: Model tingkat perusahaan yang lebih kuat, tersedia melalui Le Chat milik Mistral, SageMaker, dan cloud enterprise lainnya.

Sumber: Mistral

Magistral Small, model terbuka yang akan kita bahas, mendukung jendela konteks 128K (40K direkomendasikan untuk performa stabil). Model ini dilatih menggunakan fine-tuning terawasi pada jejak Magistral Medium dan pembelajaran penguatan.

Cara Menyiapkan dan Menjalankan Magistral Small Secara Lokal dengan Ollama

Di bagian ini, kita akan melakukan inferensi pada model Magistral milik Mistral secara lokal menggunakan Ollama. Perhatikan bahwa model ini memerlukan sekitar 14GB ruang dan dapat dimuat dalam satu RTX 4090 atau MacBook dengan RAM 32GB setelah di-kuantisasi. Saya menjalankan demo ini di MacBook Pro M3.

Langkah 1: Ambil model melalui Ollama

Unduh Ollama untuk macOS, Windows, atau Linux dari: https://ollama.com/download.

Ikuti petunjuk pemasang, dan setelah instalasi, verifikasi dengan menjalankan ini di terminal:

ollama --versionDidukung oleh

Selanjutnya, ambil model Magistral dengan menjalankan kode berikut:

ollama pull magistralDidukung oleh

Ini akan mengunduh model Magistral ke mesin lokal Anda. Catatan: Prosesnya akan memakan waktu karena ukuran model sekitar 14 GB.

Langkah 2: Instal dependensi

Mari mulai dengan memasang semua dependensi yang diperlukan.

pip install ollama
pip install requestsDidukung oleh

Dengan dependensi terpasang, kita siap menjalankan inferensi.

Langkah 3: Buat templat prompt terstruktur

Sekarang, kita menyiapkan struktur templat prompt (seperti disebutkan dalam makalah Magistral asli) yang membimbing proses berpikir model.

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]
"""Didukung oleh

Fungsi di atas menghasilkan prompt terformat yang membimbing Magistral untuk:

• Berpikir langkah demi langkah menggunakan tag <think>...</think>
• Memberikan kesimpulan yang jelas setelah monolog internalnya
• Mengabaikan penyebutan “debugging” agar penjelasan terdengar natural

Struktur ini penting untuk model seperti Magistral yang dilatih dengan prompt beralat (tool-augmented). Struktur sistem prompt yang sama juga dapat digunakan untuk masalah matematika maupun pemrograman.

Langkah 4: Streaming inferensi dan bangun UI Gradio

Pada langkah ini, kita melakukan streaming keluaran model Magistral secara real-time menggunakan API lokal Ollama. Karena kita fokus pada debugging logika yang cacat dengan penalaran transparan langkah demi langkah, penting bagi pengguna untuk melihat bagaimana model sampai pada kesimpulannya. Terakhir, kita menampilkan penjelasan melalui antarmuka Gradio yang ringkas.

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)Didukung oleh

Berikut garis besar yang terjadi di sini:

• Kita mulai dengan fungsi dapat digunakan ulang build_prompt() untuk membungkus input pengguna ke dalam prompt terstruktur yang membimbing model dengan tag penalaran <think>.
• Saat pengguna mengirimkan bukti atau pernyataan logika yang cacat, fungsi call_ollama_stream() mengirimkan prompt ke API HTTP Ollama di localhost:11434 menggunakan permintaan POST streaming.
• Fungsi mendengarkan respons yang di-stream baris demi baris menggunakan requests.iter_lines(). Untuk setiap baris yang diterima, fungsi mengekstrak field respons dari payload JSON dan menambahkannya ke penyangga teks berjalan.
• Setelah semua baris yang di-stream terkumpul, respons model lengkap dikembalikan dan ditampilkan di UI Gradio.

Berikut input yang saya coba:

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.Didukung oleh

Dalam pengujian saya di MacBook Pro M3, model menangani rantai logika sederhana dan bukti matematika dengan cukup baik. Namun, untuk tugas penalaran lebih dalam atau rantai pemikiran yang lebih panjang, sesekali model melewatkan kasus tepi—hal yang wajar untuk model 24B terbuka. Pendekatan ini ideal untuk demo penalaran yang ringan atau aplikasi chain-of-thought di perangkat tanpa bergantung pada API cloud.

Menjalankan Magistral Small dengan vLLM

Di bagian ini, saya akan menjelaskan cara menyediakan instance GPU bertenaga di RunPod, melakukan deployment model Magistral milik Mistral menggunakan vLLM, dan mengekspos API yang kompatibel dengan OpenAI untuk inferensi lokal maupun jarak jauh.

Langkah 1: Siapkan lingkungan RunPod Anda 

Sebelum meluncurkan model, pastikan akun RunPod Anda sudah siap:

• Masuk ke RunPod.io dan konfigurasikan penagihan Anda.
• Tambahkan setidaknya $10 ke saldo Anda untuk memastikan Anda bisa menjalankan satu instance GPU A100 selama proyek ini.

Langkah 2: Deploy pod dengan GPU A100

Sekarang, mari sediakan pod yang mampu menampung model. Untuk menyiapkan pod, ikuti langkah-langkah berikut:

• Buka bagian Pods dan pilih A100 SXM GPU dengan VRAM 80GB. Untuk proyek ini, kita hanya akan menggunakan satu GPU A100.

• Buka bagian “Deploy a Pod” dan klik Edit Template.

• Sekarang, naikkan container disk dan volume disk menjadi 60 GB dan klik Set Overrides.

• Berikutnya, klik Deploy On-Demand, dan pod Anda akan dideploy. Pod yang dideploy akan muncul di bagian pods beserta semua konfigurasi yang ditetapkan. Tunggu beberapa detik hingga tombol Connect aktif.

Langkah 3: Sambungkan ke pod Anda

Setelah tombol Connect dapat diklik, klik tombol tersebut. Anda akan melihat beberapa opsi koneksi—Anda bisa:

• Membuka terminal JupyterLab untuk menjalankan perintah shell atau notebook Jupyter (direkomendasikan).
• Atau gunakan port SSH atau HTTP jika Anda menginginkan kontrol jarak jauh.

Catatan: Tunggu hingga Anda melihat titik hijau 🟢dengan tanda Ready di bawah Jupyter Lab.

Klik Jupyter Lab—ini akan membawa Anda ke jendela lain dengan opsi untuk membuat notebook Jupyter baru. Buka terminal baru atau siapkan file Python baru.

Langkah 4: Instal vLLM dan pustaka yang diperlukan

Di terminal atau Jupyter Notebook di dalam pod Anda, instal vLLM dan dependensinya. 

pip install -U vllm --pre --extra-index-url https://wheels.vllm.ai/nightly
pip install gradioDidukung oleh

Pastikan juga Anda menjalankan mistral_common >= 1.6.0 dengan menjalankan:

python -c "import mistral_common; print(mistral_common.__version__)"Didukung oleh

Langkah 5: Layani model

Sekarang, mari layani modelnya. Klik tanda “+” di pojok kiri atas dan pilih terminal dari opsi, lalu jalankan perintah berikut:

vllm serve mistralai/Magistral-Small-2506 \
  --tokenizer_mode mistral \
  --config_format mistral \
  --load_format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choiceDidukung oleh

Biarkan terminal ini tetap berjalan karena perintah ini meluncurkan model Magistral Small menggunakan vLLM dan membuatnya tersedia pada endpoint API cepat yang kompatibel dengan OpenAI (http://localhost:8000/v1). Berikut penjelasan setiap flag:

Langkah 6: Men-debug logika yang cacat dengan Magistral dan vLLM

Sekarang kita akan membangun demo di mana Magistral diminta untuk men-debug logika atau bukti matematika yang cacat. Model akan menghasilkan monolog batin terperinci yang dibungkus dalam tag <think> dan ringkasan akhir.

Langkah 6.1: Inisialisasi klien OpenAI dan sistem prompt

Kita mulai dengan menyiapkan impor dan menginisialisasi klien OpenAI di Jupyter Notebook. Lalu kita menyusun sistem prompt Magistral sebagaimana disarankan dalam makalah Magistral asli.

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]"""Didukung oleh

SYSTEM_PROMPT mendefinisikan format terstruktur tentang bagaimana model harus merespons:

• Model diminta untuk menghasilkan jejak <think> terlebih dahulu (seperti monolog batin),
• Lalu menghasilkan ringkasan akhir setelah tag </think>.

Langkah 6.2: Streaming keluaran model dan izinkan interupsi

Berikutnya, kita menangani streaming keluaran model dengan menetapkan temperature, top_p, dan max_tokens sebagaimana disarankan dalam blog asli Magistral.

# 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.")Didukung oleh

Cuplikan kode di atas menangani streaming keluaran secara langsung token demi token dari model. stop_signal memungkinkan pengguna menghentikan streaming dengan mengeklik tombol "Stop".

Sementara penyangga mengakumulasi semua konten, yang ditampilkan hanya ringkasan (mengecualikan tag <think>) menggunakan ekspresi reguler. Jika terjadi kesalahan (misalnya masalah jaringan), aplikasi akan menampilkan pesan kesalahan.

Langkah 6.3: Bangun UI Gradio

Mari kita satukan semuanya dengan aplikasi Gradio sederhana yang memungkinkan pengguna memasukkan logika atau bukti yang cacat dan mengirimkannya ke model untuk penalaran.

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)Didukung oleh

Kode di atas membuat antarmuka Gradio sederhana dengan:

• Kotak input teks untuk menempelkan logika yang cacat.
• Kotak keluaran langsung yang diperbarui saat token di-stream.
• Tombol Submit untuk memulai debugger, dan tombol Stop untuk menghentikannya.

Aplikasi menggunakan gr.State untuk melacak apakah pengguna ingin menghentikan proses streaming. Lalu, metode launch() menjalankan aplikasi secara lokal dan membukanya di browser Anda. Berikut input yang saya coba:

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.Didukung oleh

Anda dapat beralih ke terminal yang sudah berjalan tempat vLLM melayani untuk memeriksa log penggunaan KV cache, serta tingkat hit yang meningkat saat model mengembalikan keluaran.

Dibandingkan dengan Ollama, vLLM terasa lebih cepat dan lebih stabil saat inferensi. Streaming terasa mulus, dan keluarannya sebagian besar terstruktur dengan baik. Meski begitu, model terkadang mengulang pikiran dalam bagian <think>, kemungkinan karena sifat decoding autoregresif tanpa penalti sampling.

Ollama vs. vLLM untuk Menjalankan Magistral Small 

Sementara Ollama mendukung versi model terkuantisasi 4-bit untuk inferensi efisien di perangkat, vLLM memerlukan akselerasi GPU, sehingga biayanya sedikit lebih tinggi (sekitar $5 untuk proyek ini). Model Magistral terkuantisasi 4-bit memerlukan sekitar 14GB memori, yang dapat dihosting pada satu GPU RTX 4090 atau bahkan MacBook dengan RAM 32GB. Namun, inferensi bisa lambat, hingga 4 menit per respons karena keterbatasan komputasi.

Sebaliknya, vLLM menawarkan inferensi yang jauh lebih cepat (sekitar kurang dari satu menit per respons) ketika dideploy pada GPU berkinerja tinggi seperti A100 SXM, sehingga lebih cocok untuk aplikasi yang responsif atau deployment skala besar.

Jika Anda sekadar bereksperimen dan memiliki sumber daya lokal, Ollama ideal karena biaya penyiapannya rendah. Namun, untuk performa setara produksi atau beban kerja yang lebih besar, vLLM adalah pilihan yang direkomendasikan. Ingat bahwa meskipun vLLM dapat dijalankan secara lokal, tetap membutuhkan GPU yang mumpuni.

Kesimpulan

Dalam tutorial ini, kita menggunakan Magistral Small—LLM berfokus penalaran dari Mistral—untuk membangun debugger logika langkah demi langkah. Kita melakukan deployment model secara lokal menggunakan Ollama untuk pengujian cepat di perangkat dan vLLM untuk inferensi GPU ber-throughput tinggi dengan API yang kompatibel dengan OpenAI. Kita juga menguji kemampuan penalaran model dengan aplikasi Gradio. Baik Anda sedang men-debug logika yang cacat maupun membangun alat AI penalaran, Magistral Small bisa menjadi solusi yang baik.