Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Distribuire Devstral in locale con vLLM

Lezione 13 di 14 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Preparare il deployment
  2. Cosa permette il tuo hardware
  3. Installare vLLM
  4. Avviare il server
  5. Adattare il comando alla tua macchina
  6. Collegare Vibe e verificare
  7. I tre problemi che incontrerai
  8. Punti chiave

Lezione aggiornata il 2 novembre 2026 sulla base della pagina Using offline models della documentazione di Vibe. Devstral è stato rimosso dalle API Mistral, ma i suoi pesi rimangono pubblicati: Devstral Small 2 e Mistral Small 4 sono i due modelli open consigliati per l’uso locale. Vibe non include un modello locale: lo colleghi a un server compatibile con OpenAI tramite un preset in config.toml, quindi passi dall’uno all’altro usando /model. Fonte: Using offline models.

Preparare il deployment

Distribuire Devstral in locale significa eseguire un server di inferenza sulla tua macchina che esponga un’API compatibile con OpenAI. Vibe vi si collega esattamente come se stesse parlando al cloud Mistral. Questa compatibilità dell’interfaccia rende il passaggio trasparente: i tuoi strumenti non hanno motivo di sapere da dove provengano le risposte. Il framework raccomandato per questo ruolo è vLLM, un motore di inferenza ad alte prestazioni sviluppato dalla comunità open source.

Cosa permette il tuo hardware

Prima di installare qualsiasi cosa, controlla la tua GPU. Essa determina la precisione utilizzabile e, di conseguenza, la dimensione della finestra di contesto a tua disposizione.

Configurazione GPU VRAM Precisione Contesto
Consigliata NVIDIA H100 / A100 80 GB FP8 ~128K token
Alternativa RTX 4090 / RTX 6000 24–48 GB 4-bit (quantizzata) ~32K token
Solo CPU Nessuna GPU 64+ GB RAM - Lenta (sconsigliata)

Nota importante: la configurazione solo CPU è funzionale ma estremamente lenta per un modello da 24B. È adatta solo per test, non per l’uso quotidiano. In altre parole, ti permette di verificare che la catena funzioni, ma non che tu possa lavorarci effettivamente.

Installare vLLM

Il prerequisito software è minimo: Python 3.10 o superiore, seguito da un pip install.

# Richiesto Python 3.10+
python3 --version

# Installa vLLM
pip install vllm

Successivamente, verifica che i driver NVIDIA e CUDA siano installati e operativi. Questo comando è il miglior test end-to-end: se mostra la tua GPU e una versione di CUDA, il livello di basso livello è sano e eventuali errori successivi proverranno da altrove.

nvidia-smi
# Deve mostrare la tua GPU e la versione di CUDA

Avviare il server

Il comando di avvio si compone di quattro argomenti, due dei quali sono essenziali per lavorare con Vibe.

vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --port 8080

Analizziamo i flag:

  • mistralai/Devstral-Small-2-24B-Instruct-2512: il modello Hugging Face da caricare
  • --tool-call-parser mistral: abilita l’analisi delle chiamate agli strumenti nel formato Mistral
  • --enable-auto-tool-choice: consente al modello di scegliere automaticamente i propri strumenti
  • --port 8080: la porta di ascolto del server

I due flag relativi agli strumenti meritano attenzione. Senza di essi, il server risponderebbe alle tue domande, ma il modello non potrebbe più leggere un file o eseguire un comando. Vibe diventerebbe un semplice chatbot, il che non è l’obiettivo.

Adattare il comando alla tua macchina

Se disponi di più GPU, il parallelismo tensoriale distribuisce il modello su tutte le schede. La VRAM combinata consente quindi una finestra di contesto più ampia.

vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --tensor-parallel-size 2 \
  --port 8080

Su una configurazione più modesta, devi abbassare la precisione. Una H100 o A100 gestisce FP8; una RTX 4090 utilizzerà la quantizzazione a 4 bit con AWQ, al costo di una leggera perdita di qualità ampiamente compensata dal fatto che il modello entra finalmente in memoria.

# FP8 su H100/A100
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --dtype float16 \
  --port 8080

# 4-bit su RTX 4090
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --quantization awq \
  --port 8080

L’ultima leva quando la VRAM rimane insufficiente è ridurre la lunghezza massima del contesto. La cache di attenzione consuma memoria in proporzione al contesto e scendere a 16.384 token libera spesso quanto mancava per avviare il processo.

vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 16384 \
  --port 8080

Collegare Vibe e verificare

Il server è in esecuzione; ora devi dire a Vibe di usarlo. Vibe non include un modello locale: dichiara un provider e un preset di modello in config.toml.

# ~/.vibe/config.toml
active_model = "devstral-local"

[[providers]]
name = "local"
api_base = "http://localhost:8080/v1"
api_style = "openai"
backend = "generic"

[[models]]
name = "mistralai/Devstral-Small-2-24B-Instruct-2512"
provider = "local"
alias = "devstral-local"

Mantieni active_model sopra la prima tabella [[...]], altrimenti TOML lo assocerà a quella tabella. Imposta max_context_length nel preset per indicare il contesto del tuo server, che deve anche restituire l’utilizzo in token nelle risposte in streaming (stream_options.include_usage). Variante più breve: Vibe fornisce un provider predefinito, llamacpp, che punta a http://127.0.0.1:8080/v1 senza chiave; in tal caso, scrivi provider = "llamacpp" nel preset, senza un blocco [[providers]]. In una sessione, /model permette di passare dal modello locale a quelli ospitati.

Testa la catena a due livelli: prima l’API grezza, che conferma che il modello è caricato, poi una richiesta reale in Vibe per validare che le chiamate agli strumenti funzionino.

# Test diretto dell'API
curl http://localhost:8080/v1/models

# Test in Vibe (l'agente ask richiede conferma prima di ogni strumento)
vibe --agent ask
> List files in the current directory

Per l’uso quotidiano, riavviare manualmente il comando diventa rapidamente noioso. Un servizio systemd avvia il server all’accensione e lo riavvia in caso di crash.

# Crea un servizio systemd
sudo tee /etc/systemd/system/vllm-devstral.service << EOF
[Unit]
Description=vLLM Devstral Server
After=network.target

[Service]
Type=simple
User=$USER
ExecStart=/usr/local/bin/vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 --tool-call-parser mistral --enable-auto-tool-choice --port 8080
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable --now vllm-devstral

I tre problemi che incontrerai

Un errore CUDA out of memory significa che il modello non entra: riduci --max-model-len o passa alla quantizzazione a 4 bit. La lentezza al primo avvio è normale e non è un sintomo: l’avvio iniziale scarica e carica il modello, circa 14 GB, e gli avvii successivi beneficiano della cache. Infine, se Vibe non trova il server locale, controlla semplicemente che la porta 8080 sia in ascolto prima di cercare oltre.

curl http://localhost:8080/health

Punti chiave

  • vLLM è il framework consigliato per servire Devstral in locale
  • I flag --tool-call-parser mistral e --enable-auto-tool-choice sono obbligatori
  • Una H100/A100 offre FP8 e contesto 128K; una RTX 4090 offre 4-bit e 32K
  • Riduci --max-model-len se la VRAM è insufficiente
  • Collega Vibe tramite un provider e un preset di modello in config.toml (o il provider predefinito llamacpp), quindi usa /model
  • Esegui vLLM come servizio systemd per l’uso quotidiano