Guida rapida a Devstral: esegui in locale l'LLM di Mistral AI

Sembra che nuovi modelli di AI arrivino a ritmo serrato, e Mistral AI ha alzato ulteriormente l’asticella con il lancio di Devstral, un rivoluzionario modello di coding open source. Devstral è un LLM agentico per il coding che può essere eseguito in locale su una GPU RTX 4090 o su un Mac con 32 GB di RAM, rendendolo accessibile per il deployment locale e l’uso on-device. È veloce, accurato e liberamente utilizzabile. 

In questo tutorial vedremo tutto ciò che ti serve sapere su Devstral, comprese le sue funzionalità chiave e cosa lo rende unico. Impareremo anche a eseguirlo in locale con strumenti come Mistral Chat CLI e a integrare la Mistral AI API con OpenHands per testare le capacità agentiche di Devstral.

Puoi approfondire altri strumenti di Mistral in guide dedicate, tra cui Mistral Medium 3, Mistral OCR API e Mistral Le Chat. 

Che cos’è Mistral Devstral?

Devstral è un modello agentico all’avanguardia progettato per compiti di ingegneria del software. È stato sviluppato da Mistral AI in collaborazione con All Hands AI. Eccelle nella risoluzione di sfide di coding reali, come l’esplorazione di grandi codebase, la modifica di più file e la risoluzione di problemi su repository GitHub. 

Le prestazioni di Devstral sul benchmark SWE-Bench Verified sono senza precedenti: ha raggiunto un punteggio del 46,8%, che lo posiziona come il modello open source n. 1 su questo benchmark, superando i precedenti modelli all’avanguardia del 6%.

Fonte: Devstral | Mistral AI

Basato su Mistral-Small-3.1, Devstral offre una finestra di contesto da 128k, che gli consente di elaborare e comprendere grandi quantità di codice e dipendenze. A differenza del modello di base, Devstral è solo testo: durante il fine-tuning è stato rimosso l’encoder di visione per specializzarlo nei compiti di programmazione. 

La capacità di lavorare in modo fluido con strumenti come OpenHands gli permette di superare anche modelli molto più grandi, come Deepseek-V3-0324 (671B) e Qwen3 232B-A22B.

Funzionalità principali di Devstral

Ecco alcune caratteristiche di rilievo di Devstral che lo distinguono dagli altri modelli per il coding.

1. Coding agentico

Devstral è progettato specificamente per eccellere nelle attività di coding agentico, rendendolo un modello ideale per costruire e distribuire agenti di ingegneria del software. La sua capacità di risolvere compiti complessi e multi-step all’interno di grandi codebase consente agli sviluppatori di affrontare efficacemente sfide reali di programmazione.

2. Design leggero

Una delle caratteristiche più notevoli di Devstral è la sua architettura leggera. Con soli 24 miliardi di parametri, può girare su una singola Nvidia RTX 4090. Questa caratteristica lo rende ideale per il deployment locale, l’uso on-device e le applicazioni sensibili alla privacy.

3. Open source 

Rilasciato sotto licenza Apache 2.0, Devstral è liberamente disponibile per uso commerciale. Sviluppatori e organizzazioni possono distribuirlo, modificarlo e persino integrarlo in prodotti proprietari senza restrizioni.

4. Finestra di contesto estesa

Devstral offre un’impressionante finestra di contesto da 128k, che gli consente di elaborare e comprendere enormi quantità di codice e istruzioni in una singola interazione. È particolarmente efficace per lavorare con grandi codebase e risolvere problemi di programmazione complessi.

5. Tokenizer avanzato

Devstral utilizza un tokenizer Tekken con un vocabolario da 131k, che gli permette di gestire input di codice e testo con precisione ed efficienza. Questo tokenizer migliora la capacità del modello di generare risposte accurate e contestualizzate, su misura per i compiti di ingegneria del software.

Primi passi con Devstral

Devstral è liberamente scaricabile da piattaforme come Hugging Face, Ollama, Kaggle, Unsloth e LM Studio. Gli sviluppatori possono anche accederci via API con il nome devstral-small-2505 a prezzi competitivi: 0,10 $ per milione di token in input e 0,30 $ per milione di token in output.

In questa guida, vedremo due workflow chiave:

1. Eseguire Devstral in locale usando Mistral inference.
2. Integrare Devstral con OpenHands per costruire progetti di machine learning.

Eseguire Devstral in locale

Per eseguire Devstral in locale, useremo un’istanza Runpod con supporto GPU, scaricheremo il modello da Hugging Face e interagiremo con esso tramite lo strumento CLI mistral-chat.

1. Configura il pod con 100 GB di storage e GPU A100 SXM, quindi avvia l’istanza JupyterLab.

2. Esegui i seguenti comandi in un Jupyter Notebook per installare le dipendenze necessarie:

%%capture
%pip install mistral_inference --upgrade
%pip install huggingface_hub

3. Usa Hugging Face Hub per scaricare i file del modello, il tokenizer e la configurazione dei parametri. 

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)

4. Apri un terminale in JupyterLab ed esegui il seguente comando per avviare la CLI mistral-chat:

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

5. Prova il seguente prompt per testare Devstral:

«Crea da zero una REST API usando Python.»

Il modello ha generato una risposta dettagliata e accurata: una guida passo passo per creare una REST API con 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
=====================

Eseguire Devstral con OpenHands

Puoi accedere facilmente al modello Devstral tramite la Mistral AI API. In questo progetto useremo l’API di Devstral insieme a OpenHands per costruire da zero un progetto di machine learning. OpenHands è una piattaforma open source che funge da tuo software engineer AI per costruire e completare il tuo progetto di coding.

1. Visita la piattaforma Mistral AI e genera la tua chiave API.

2. Carica 5 $ sul tuo account tramite carta di debito/credito. 

3. Esegui il seguente script per 

• Impostare la chiave API come variabile d’ambiente.
• Scaricare l’immagine Docker di OpenHands.
• Creare il file di configurazione.
• Avviare l’applicazione OpenHands in un container 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.39

L’applicazione web sarà disponibile su 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)

Testare Devstral in OpenHands

1. Clicca sul pulsante “Launch from Scratch” per iniziare a creare un progetto.

2.   Verrai reindirizzato alla nuova UI, che include un’interfaccia chat e altre schede per l’inferenza di sviluppo.

3. Usa l’interfaccia chat per fornire i prompt. Nel giro di un secondo, Devstral inizierà a creare directory, file e codice per il progetto.

4. Passa alla scheda VS Code per visualizzare, modificare ed eseguire il codice generato.

5. Devstral è così efficace che ha avviato l’applicazione, la sta testando nell’app web e utilizza anche il web agent per navigare nella pagina.

Una volta completato il progetto, pubblicalo su GitHub per condividerlo con il tuo team.

Conclusione

Devstral è un’ottima notizia per la community open source. Puoi usare OpenHands con Ollama o VLLM per eseguire il modello in locale e poi interagirci tramite l’UI di OpenHands. Inoltre, puoi integrare Devstral nel tuo editor di codice tramite estensioni, rendendolo un’opzione altamente efficace.

In questo tutorial abbiamo esplorato Devstral, un modello di coding agentico, e ne abbiamo testato le capacità eseguendolo in locale e usando OpenHands. I risultati sono stati impressionanti. Devstral è veloce, molto accurato ed eccelle nell’invocare agenti per svolgere compiti complessi. La sua capacità di gestire sfide reali di ingegneria del software con rapidità e precisione lo rende una scelta di spicco per gli sviluppatori.

Puoi saperne di più sull’Agentic AI con il nostro articolo sul blog e fare pratica con il nostro corso Designing Agentic Systems with LangChain.