Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Distribuera Devstral lokalt med vLLM

Lektion 13 av 14 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Förbered distributionen
  2. Vad din hårdvara tillåter
  3. Installera vLLM
  4. Starta servern
  5. Anpassa kommandot till din maskin
  6. Anslut Vibe och verifiera
  7. De tre problemen du kommer att stöta på
  8. Viktiga punkter

Lektionen uppdaterad 2 november 2026 baserat på sidan Using offline models i Vibe-dokumentationen. Devstral har tagits bort från Mistral API, men dess vikter finns fortfarande publicerade: Devstral Small 2 och Mistral Small 4 är de två rekommenderade öppna modellerna för lokal användning. Vibe levereras inte med en lokal modell: du ansluter den till en OpenAI-kompatibel server via en förinställning i config.toml och växlar sedan med /model. Källa: Using offline models.

Förbered distributionen

Att distribuera Devstral lokalt innebär att du kör en inferensserver på din maskin som exponerar ett OpenAI-kompatibelt API. Vibe ansluter sedan till den exakt som om den pratade med Mistral-molnet. Denna gränssnittskompatibilitet gör bytet sömlöst; dina verktyg har ingen anledning att veta var svaren kommer ifrån. Det rekommenderade ramverket för denna roll är vLLM, en högpresterande inferensmotor utvecklad av open source-communityt.

Vad din hårdvara tillåter

Innan du installerar något måste du kontrollera ditt GPU. Det avgör den användbara precisionen och därmed storleken på kontextfönstret du kommer att ha tillgängligt.

Konfiguration GPU VRAM Precision Kontext
Rekommenderat NVIDIA H100 / A100 80 GB FP8 ~128K tokens
Alternativ RTX 4090 / RTX 6000 24–48 GB 4-bit (kvantiserad) ~32K tokens
Endast CPU Inget GPU 64+ GB RAM - Långsam (rekommenderas ej)

Viktigt: Konfigurationen med endast CPU fungerar men är extremt långsam för en 24B-modell. Den passar bara för testning, inte för dagligt bruk. Med andra ord låter den dig verifiera att kedjan fungerar, men inte att du faktiskt kan arbeta med den.

Installera vLLM

Mjukvarukraven är minimala: Python 3.10 eller högre, följt av en pip install.

# Python 3.10+ krävs
python3 --version

# Installera vLLM
pip install vllm

Kontrollera därefter att NVIDIA-drivrutinerna och CUDA är installerade och fungerar. Detta kommando är det bästa end-to-end-testet: om det visar ditt GPU och en CUDA-version är lågnivålagret friskt, och eventuella efterföljande fel kommer från någon annanstans.

nvidia-smi
# Måste visa ditt GPU och CUDA-versionen

Starta servern

Startkommandot ryms i fyra argument, varav två är avgörande för att arbeta med Vibe.

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

Låt oss bryta ner flaggorna:

  • mistralai/Devstral-Small-2-24B-Instruct-2512: Hugging Face-modellen som ska laddas
  • --tool-call-parser mistral: Aktiverar tolkning av verktygsanrop i Mistral-format
  • --enable-auto-tool-choice: Tillåter modellen att automatiskt välja sina verktyg
  • --port 8080: Serverns lyssnande port

De två flaggorna relaterade till verktyg förtjänar uppmärksamhet. Utan dem skulle servern svara på dina frågor, men modellen skulle inte längre kunna läsa en fil eller köra ett kommando. Vibe skulle bli en enkel chattbot, vilket inte är målet.

Anpassa kommandot till din maskin

Om du har flera GPU:er fördelar tensorparallellism modellen över alla kort. Den kombinerade VRAM:en möjliggör då ett bredare kontextfönster.

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

På en mer blygsam konfiguration behöver du sänka precisionen. En H100 eller A100 hanterar FP8; en RTX 4090 använder 4-bitars kvantisering med AWQ, till priset av en liten kvalitetsförlust som mer än väl kompenseras av att modellen faktiskt får plats i minnet.

# FP8 på 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 på RTX 4090
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --quantization awq \
  --port 8080

Den sista hävstången när VRAM fortfarande är otillräcklig är att minska den maximala kontextlängden. Attention-cache:n förbrukar minne proportionellt mot kontexten, och att gå ner till 16 384 tokens frigör ofta det som saknades för att starta.

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

Anslut Vibe och verifiera

Servern körs; nu måste du tala om för Vibe att använda den. Vibe levereras inte med en lokal modell: deklarera en leverantör och en modelförinställning i 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"

Placera active_model ovanför den första [[...]]-tabellen, annars kommer TOML att fästa den vid den tabellen. Ställ in max_context_length i förinställningen för att ange din servers kontext, som också måste returnera användning i tokens i strömmande svar (stream_options.include_usage). Kortare variant: Vibe tillhandahåller en fördefinierad leverantör, llamacpp, som pekar på http://127.0.0.1:8080/v1 utan nyckel; skriv i så fall provider = "llamacpp" i förinställningen, utan ett [[providers]]-block. I en session växlar /model mellan den lokala modellen och värdmodeller.

Testa kedjan på två nivåer: först det råa API:t, vilket bekräftar att modellen är laddad, sedan en riktig begäran i Vibe för att validera att verktygsanrop fungerar.

# Direkt API-test
curl http://localhost:8080/v1/models

# Test i Vibe (ask-agenten begär tillstånd före varje verktyg)
vibe --agent ask
> List files in the current directory

För dagligt bruk blir det snabbt tröttsamt att manuellt starta om kommandot. En systemd-tjänst startar servern vid uppstart och startar om den vid krasch.

# Skapa en systemd-tjänst
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

De tre problemen du kommer att stöta på

Ett felmeddelande om CUDA out of memory betyder att modellen inte får plats: minska --max-model-len eller byt till 4-bitars kvantisering. Långsamhet vid den allra första starten är normalt och inget symptom – den initiala starten laddar ner och laddar modellen, cirka 14 GB, och efterföljande starter drar nytta av cachen. Om Vibe slutligen inte hittar den lokala servern, kontrollera helt enkelt att port 8080 lyssnar innan du letar vidare.

curl http://localhost:8080/health

Viktiga punkter

  • vLLM är det rekommenderade ramverket för att serva Devstral lokalt
  • Flaggorna --tool-call-parser mistral och --enable-auto-tool-choice är obligatoriska
  • En H100/A100 erbjuder FP8 och 128K kontext; en RTX 4090 erbjuder 4-bit och 32K
  • Minska --max-model-len om VRAM är otillräcklig
  • Anslut Vibe via en leverantör och modelförinställning i config.toml (eller den fördefinierade llamacpp-leverantören), använd sedan /model
  • Kör vLLM som en systemd-tjänst för dagligt bruk