Panduan Cepat Devstral: Menjalankan LLM Mistral AI Secara Lokal

Rasanya model AI baru hadir begitu cepat, dan Mistral AI menambah antusiasme tersebut dengan meluncurkan Devstral, model pengodean sumber terbuka yang inovatif. Devstral adalah model bahasa besar (LLM) pengodean Agentic yang dapat dijalankan secara lokal pada GPU RTX 4090 atau Mac dengan RAM 32GB, sehingga mudah diakses untuk penerapan lokal dan penggunaan di perangkat. Model ini cepat, akurat, dan terbuka untuk digunakan. 

Dalam tutorial ini, kita akan mempelajari semua yang perlu Anda ketahui tentang Devstral, termasuk fitur utamanya dan apa yang membuatnya unik. Kita juga akan menjalankan Devstral secara lokal menggunakan alat seperti Mistral Chat CLI dan mengintegrasikan Mistral AI API dengan OpenHands untuk menguji kapabilitas agentic Devstral.

Anda dapat mempelajari lebih lanjut tentang alat lain dari Mistral dalam panduan terpisah, termasuk Mistral Medium 3, Mistral OCR API, dan Mistral Le Chat. 

Apa itu Mistral Devstral?

Devstral adalah model agentic mutakhir yang dirancang untuk tugas rekayasa perangkat lunak. Model ini dikembangkan oleh Mistral AI bekerja sama dengan All Hands AI. Devstral unggul dalam menyelesaikan tantangan pengodean dunia nyata, seperti menelusuri basis kode besar, mengedit banyak berkas, dan menyelesaikan isu di repositori GitHub. 

Performa Devstral pada tolok ukur SWE-Bench Verified tak tertandingi, meraih skor 46,8%, menjadikannya model sumber terbuka nomor satu pada tolok ukur ini, melampaui model-model mutakhir sebelumnya sebesar 6%.

Sumber: Devstral | Mistral AI

Dibangun di atas Mistral-Small-3.1, Devstral memiliki jendela konteks 128k, memungkinkannya memproses dan memahami sejumlah besar kode dan dependensi. Berbeda dengan model dasarnya, Devstral hanya berbasis teks, karena encoder visi dihapus saat fine-tuning untuk memfokuskan diri pada tugas pengodean. 

Kemampuannya untuk bekerja mulus dengan alat seperti OpenHands membuatnya mampu mengungguli bahkan model yang jauh lebih besar, seperti Deepseek-V3-0324 (671B) dan Qwen3 232B-A22B.

Fitur Utama Devstral

Berikut beberapa fitur menonjol Devstral yang membuatnya berbeda dari model pengodean lainnya.

1. Pengodean agentic

Devstral dirancang khusus untuk unggul dalam tugas pengodean agentic, menjadikannya model ideal untuk membangun dan menerapkan agen rekayasa perangkat lunak. Kemampuannya menyelesaikan tugas kompleks bertahap dalam basis kode besar memungkinkan pengembang menangani tantangan pengodean dunia nyata secara efektif.

2. Desain ringan

Salah satu fitur menonjol Devstral adalah arsitektur yang ringan. Dengan hanya 24 miliar parameter, model ini dapat berjalan pada satu GPU Nvidia RTX 4090. Fitur ini ideal untuk penerapan lokal, penggunaan di perangkat, dan aplikasi yang sensitif terhadap privasi.

3. Sumber terbuka 

Dirilis di bawah lisensi Apache 2.0, Devstral tersedia bebas untuk penggunaan komersial. Pengembang dan organisasi dapat menerapkan, memodifikasi, dan bahkan mengintegrasikannya ke dalam produk proprieter tanpa batasan.

4. Jendela konteks diperluas

Devstral memiliki jendela konteks 128k yang mengesankan, memungkinkannya memproses dan memahami sejumlah besar kode serta instruksi dalam satu interaksi. Ini sangat efektif untuk bekerja dengan basis kode besar dan menyelesaikan masalah pemrograman kompleks.

5. Tokenizer canggih

Devstral menggunakan tokenizer Tekken dengan ukuran kosakata 131k, sehingga mampu menangani input kode dan teks dengan presisi dan efisiensi. Tokenizer ini meningkatkan kemampuan model untuk menghasilkan respons yang akurat dan kontekstual yang disesuaikan untuk tugas rekayasa perangkat lunak.

Mulai Menggunakan Devstral

Devstral tersedia gratis untuk diunduh di platform seperti Hugging Face, Ollama, Kaggle, Unsloth, dan LM Studio. Pengembang juga dapat mengaksesnya melalui API dengan nama devstral-small-2505 dengan harga kompetitif: $0,10 per satu juta token input dan $0,30 per satu juta token output.

Dalam panduan ini, kita akan membahas dua alur kerja utama:

1. Menjalankan Devstral secara lokal menggunakan Mistral inference.
2. Mengintegrasikan Devstral dengan OpenHands untuk membangun proyek machine learning.

Menjalankan Devstral secara lokal

Untuk menjalankan Devstral secara lokal, kita akan menggunakan instance Runpod dengan dukungan GPU, mengunduh model dari Hugging Face, dan berinteraksi dengannya menggunakan alat CLI mistral-chat.

1. Siapkan pod dengan penyimpanan 100GB dan GPU A100 SXM, lalu luncurkan instance JupyterLab.

2. Jalankan perintah berikut di Jupyter Notebook untuk menginstal dependensi yang diperlukan:

%%capture
%pip install mistral_inference --upgrade
%pip install huggingface_hubDidukung oleh

3. Gunakan Hugging Face Hub untuk mengunduh file model, tokenizer, dan konfigurasi parameter. 

from huggingface_hub import snapshot_download
from pathlib import Path

mistral_models_path = Path.home().joinpath('mistral_models', 'Devstral')
mistral_models_path.mkdir(parents=True, exist_ok=True)

snapshot_download(repo_id="mistralai/Devstral-Small-2505", allow_patterns=["params.json", "consolidated.safetensors", "tekken.json"], local_dir=mistral_models_path)Didukung oleh

4. Buka terminal di JupyterLab dan jalankan perintah berikut untuk memulai CLI mistral-chat:

mistral-chat $HOME/mistral_models/Devstral --instruct --max_tokens 300Didukung oleh

5. Coba prompt berikut untuk menguji Devstral:

“Buat REST API dari nol menggunakan Python.”

Model menghasilkan respons yang detail dan akurat, berupa panduan langkah demi langkah untuk membangun REST API menggunakan Flask.

Creating a REST API from scratch using Python involves several steps. We'll use the Flask framework, which is lightweight and easy to get started with. Below is a step-by-step guide to creating a simple REST API.
### Step 1: Install Flask
First, you need to install Flask. You can do this using pip:

```bash
pip install Flask
```

### Step 2: Create the Flask Application

Create a new Python file, for example, `app.py`, and set up the basic structure of your Flask application.

```python
from flask import Flask, request, jsonify

app = Flask(__name__)

# Sample data
items = [
    {"id": 1, "name": "Item 1", "description": "This is item 1"},
    {"id": 2, "name": "Item 2", "description": "This is item 2"}
]

@app.route('/items', methods=['GET'])
def get_items():
    return jsonify(items)

@app.route('/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    item = next((item for item in items if item["id"] == item_id), None)
    if item:
        return jsonify(item)
    return jsonify({"error": "Item not found"}), 404

@app.route('/items', methods=['POST'])
def create_item():
    new_item = request.get_json()
    new_item["id"] = len(items
=====================
Didukung oleh

Menjalankan Devstral dengan OpenHands

Anda dapat dengan mudah mengakses model Devstral melalui Mistral AI API. Dalam proyek ini, kita akan menggunakan Devstral API bersama OpenHands untuk membangun proyek machine learning kita dari awal. OpenHands adalah platform sumber terbuka yang berperan sebagai insinyur perangkat lunak AI Anda untuk membangun dan menuntaskan proyek pengodean.

1. Kunjungi platform Mistral AI dan buat kunci API Anda.

2. Isi saldo $5 ke akun Anda menggunakan kartu Debit/Kredit. 

3. Jalankan skrip berikut untuk 

• Menyetel Kunci API sebagai variabel lingkungan.
• Mengambil image Docker OpenHands.
• Membuat berkas konfigurasi.
• Menjalankan aplikasi OpenHands dalam kontainer Docker.

# Store the API key securely as an environment variable (avoid hardcoding in scripts)
export MISTRAL_API_KEY=<MY_KEY>

# Pull the runtime image for OpenHands
docker pull docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik

# Create a configuration directory and settings file for OpenHands
mkdir -p ~/.openhands-state
cat << EOF > ~/.openhands-state/settings.json
{
  "language": "en",
  "agent": "CodeActAgent",
  "max_iterations": null,
  "security_analyzer": null,
  "confirmation_mode": false,
  "llm_model": "mistral/devstral-small-2505",
  "llm_api_key": "${MISTRAL_API_KEY}",
  "remote_runtime_resource_factor": null,
  "github_token": null,
  "enable_default_condenser": true
}
EOF

# Run the OpenHands application in a Docker container with enhanced settings
docker run -it --rm --pull=always \
    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik \
    -e LOG_ALL_EVENTS=true \
    -e TZ=$(cat /etc/timezone 2>/dev/null || echo "UTC") \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v ~/.openhands-state:/.openhands-state \
    -p 3000:3000 \
    --add-host host.docker.internal:host-gateway \
    --name openhands-app \
    --memory="4g" \
    --cpus="2" \
    docker.all-hands.dev/all-hands-ai/openhands:0.39Didukung oleh

Aplikasi web akan tersedia di http://0.0.0.0:3000

0.39-nikolaik: Pulling from all-hands-ai/runtime
Digest: sha256:126448737c53f7b992a4cf0a7033e06d5289019b32f24ad90f5a8bbf35ce3ac7
Status: Image is up to date for docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik
docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik
0.39: Pulling from all-hands-ai/openhands
Digest: sha256:326ddb052763475147f25fa0d6266cf247d82d36deb9ebb95834f10f08e4777d
Status: Image is up to date for docker.all-hands.dev/all-hands-ai/openhands:0.39
Starting OpenHands...
Running OpenHands as root
10:34:24 - openhands:INFO: server_config.py:50 - Using config class None
INFO:     Started server process [9]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:3000 (Press CTRL+C to quit)Didukung oleh

Menguji Devstral di OpenHands

1. Klik tombol “Launch from Scratch” untuk mulai membangun proyek.

2.   Anda akan diarahkan ke UI baru, yang memiliki antarmuka chat dan tab lain untuk inferensi pengembangan.

3. Gunakan antarmuka chat untuk memberikan prompt. Dalam hitungan detik, Devstral akan mulai membuat direktori, berkas, dan kode untuk proyek.

4. Beralih ke tab VS Code untuk melihat, mengedit, dan mengeksekusi kode yang dihasilkan.

5. Devstral begitu andal sehingga telah memulai aplikasi, melakukan pengujian di aplikasi web, dan juga menggunakan agen web untuk menelusuri halaman web.

Setelah proyek selesai, dorong ke GitHub untuk dibagikan dengan tim Anda.

Kesimpulan

Devstral adalah kabar baik bagi komunitas sumber terbuka. Anda dapat menggunakan OpenHands dengan Ollama atau VLLM untuk menjalankan model secara lokal lalu berinteraksi dengannya melalui UI OpenHands. Selain itu, Anda dapat mengintegrasikan Devstral ke editor kode Anda menggunakan ekstensi, menjadikannya opsi yang sangat efektif.

Dalam tutorial ini, kita mengeksplorasi Devstral, model pengodean agentic, dan menguji kemampuannya dengan menjalankannya secara lokal dan menggunakan OpenHands. Hasilnya mengesankan. Devstral cepat, sangat akurat, dan unggul dalam memanggil agen untuk melakukan tugas kompleks. Kemampuannya menangani tantangan rekayasa perangkat lunak dunia nyata dengan cepat dan presisi menjadikannya pilihan unggulan bagi pengembang.

Anda dapat mempelajari lebih lanjut tentang Agentic AI melalui artikel blog kami, dan mempraktikkannya dengan kursus kami, Designing Agentic Systems with LangChain.