Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Alojar o Devstral localmente

Aula 13 de 14 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Porquê alojar o Devstral localmente?
  2. Modelos recomendados
  3. Pré-requisitos de hardware
  4. Implementação com vLLM
  5. Utilização do servidor local
  6. Estruturas alternativas
  7. Ligar o Vibe ao servidor local
  8. Pontos-chave

Lição atualizada a 2 de novembro de 2026 com base na página Using offline models da documentação do Vibe: o Devstral foi removido da API, mas o Devstral Small 2 mantém-se, juntamente com o Mistral Small 4, como um dos dois modelos abertos recomendados para utilização local. As estimativas de custos sem fontes foram removidas e a ligação do Vibe a um servidor local segue agora a sintaxe oficial do config.toml. Fonte: Using offline models.

Porquê alojar o Devstral localmente?

O Devstral Small 2 foi lançado com pesos abertos sob a licença Apache 2.0 (o Devstral 2, o seu “irmão mais velho” de 123 mil milhões de parâmetros, utiliza uma licença MIT modificada). Embora tenha sido removido da API da Mistral a 31 de março de 2026, não desapareceu: pode implementá-lo nos seus próprios servidores sem enviar uma única linha de código para uma API externa, e a documentação do Vibe continua a recomendá-lo para este fim.

As motivações sobrepõem-se frequentemente. A privacidade vem em primeiro lugar: o seu código nunca sai da sua infraestrutura, pondo fim a quaisquer debates sobre os termos de utilização de um fornecedor. Segue-se a latência, uma vez que não existe qualquer ida e volta pela rede até à API da Mistral entre as suas teclas e a sugestão. A estrutura de custos muda: paga um preço fixo por uma GPU em vez de uma faturação baseada no uso, o que se torna vantajoso assim que uma equipa inteira consulta o modelo durante todo o dia. Por fim, existe a conformidade, exigida por certos regulamentos e setores como o bancário ou a defesa, e a disponibilidade, já que nenhum serviço de terceiros pode interromper o seu trabalho.

Modelos recomendados

A documentação do Vibe recomenda dois modelos abertos para utilização local:

  • Devstral Small 2 (mistralai/Devstral-Small-2-24B-Instruct-2512 no Hugging Face): 24 mil milhões de parâmetros, denso, treinado para tarefas de agentes e programação, com a pegada de hardware mais ligeira;
  • Mistral Small 4: 119 mil milhões de parâmetros numa arquitetura de mistura de especialistas (mixture-of-experts), com 6,5 mil milhões ativos, um modelo híbrido de raciocínio e programação com um contexto de 256.000 tokens, sob a licença Apache 2.0.

Pré-requisitos de hardware

Para um desempenho decente em contextos longos, a documentação recomenda uma implementação FP8 com um contexto de cerca de 128.000 tokens:

ConfiguraçãoHardwarePrecisãoContexto
RecomendadoGPU H100 ou A100FP8~128.000 tokens
Estação de trabalho de desenvolvimentoRTX 4090 ou qualquer GPU com 24 GB de VRAM4-bit~32.000 tokens
Sem GPUOffload para CPU, com RAM suficiente—— significativamente mais lento

Estes valores aplicam-se ao Devstral Small 2. O Mistral Small 4 requer muito mais memória de vídeo para carregar os seus pesos: conte com pelo menos uma H100 de 80 GB em FP8, e mais para contextos longos. Ajuste depois a precisão e o comprimento do contexto ao seu hardware.

Implementação com vLLM

O vLLM é a estrutura de inferência recomendada pela documentação do Vibe para servir o Devstral. A instalação requer apenas um comando.

pip install vllm

O servidor inicia-se então numa única linha, com as duas opções que tornam o modelo utilizável no modo de agente.

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

Três variantes cobrem a maioria das situações reais: dividir o modelo entre várias GPUs, reduzir a precisão quando a VRAM é escassa ou diminuir o contexto pela mesma razão.

# Multi-GPU (se tiver 2+ GPUs)
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --tensor-parallel-size 2 \
  --port 8080

# Precisão reduzida (para GPUs com menos VRAM)
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --dtype float16 \
  --port 8080

# Contexto reduzido (para poupar VRAM)
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 32768 \
  --port 8080

Eis o que cada sinalizador controla:

  • --tool-call-parser mistral — ativa a análise de chamadas de ferramentas no formato Mistral
  • --enable-auto-tool-choice — permite que o modelo decida quando chamar uma ferramenta
  • --tensor-parallel-size — divide o modelo entre várias GPUs
  • --dtype — controla a precisão (float16, bfloat16, float32)
  • --max-model-len — limita o tamanho do contexto para poupar VRAM

Os dois primeiros merecem atenção especial: omiti-los resulta num servidor que funciona perfeitamente para conversação, mas falha silenciosamente assim que um agente tenta chamar uma ferramenta. Esta é a causa mais comum de uma implementação local ser considerada “dececionante”.

Utilização do servidor local

Assim que o vLLM estiver em execução, a porta 8080 expõe uma API compatível com a OpenAI. O SDK da Mistral liga-se a ele simplesmente alterando o URL do servidor; a chave já não é necessária.

from mistralai.client import Mistral

# Apontar para o servidor local
client = Mistral(
    api_key="dummy",  # Não é necessária chave localmente
    server_url="http://localhost:8080",
)

response = client.chat.complete(
    model="mistralai/Devstral-Small-2-24B-Instruct-2512",
    messages=[
        {"role": "user", "content": "Analyze this code and suggest improvements."}
    ],
)

O SDK da OpenAI funciona igualmente bem, permitindo-lhe migrar o código existente para o Devstral local sem o reescrever.

from openai import OpenAI

client = OpenAI(
    api_key="dummy",
    base_url="http://localhost:8080/v1",
)

response = client.chat.completions.create(
    model="mistralai/Devstral-Small-2-24B-Instruct-2512",
    messages=[
        {"role": "user", "content": "Explain this code."}
    ],
)

Estruturas alternativas

O vLLM não é o único caminho: o Devstral funciona com qualquer estrutura de inferência que exponha uma API compatível com a OpenAI. A documentação do Vibe cita o llama.cpp, adequado para configurações com pouca VRAM graças aos seus modelos quantizados GGUF, o LM Studio, que oferece uma interface gráfica sem linha de comandos, e o Ollama. Verifique o nome exato do modelo e a quantização em cada ferramenta antes de comparar os resultados.

Ligar o Vibe ao servidor local

O Vibe não inclui um modelo local: assim que o seu servidor estiver em execução, declare um fornecedor e uma predefinição de modelo no config.toml. Para um servidor compatível com a OpenAI na porta 8080:

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"

Três precauções da documentação: mantenha active_model acima do primeiro array [[...]], ou o TOML irá anexá-lo a esse array; defina max_context_length na predefinição para indicar o contexto do seu servidor; e verifique se o servidor devolve a utilização de tokens nas respostas em streaming (stream_options.include_usage). O Vibe fornece também um fornecedor predefinido, llamacpp, que aponta para http://127.0.0.1:8080/v1 sem chave: nesse caso, basta escrever provider = "llamacpp" na predefinição. O comando /model alterna então entre o modelo local e os modelos alojados.

Para um funcionamento totalmente offline, desative também a telemetria e as verificações de atualização:

enable_telemetry = false
enable_update_checks = false

Com estas definições e um fornecedor local, a CLI deixa de contactar mistral.ai. As competências, servidores MCP e conectores que acedem a sistemas externos devem ser desativados separadamente.

Pontos-chave

  • O Devstral foi removido da API, mas o Devstral Small 2 (24B, Apache 2.0) continua recomendado para uso local, juntamente com o Mistral Small 4
  • O vLLM é a estrutura recomendada; --tool-call-parser mistral e --enable-auto-tool-choice são essenciais para um agente
  • H100 ou A100 em FP8 com ~128k de contexto; uma GPU de 24 GB em 4-bit com ~32k
  • O servidor expõe uma API compatível com a OpenAI, utilizável com o SDK da Mistral ou o SDK da OpenAI
  • O Vibe liga-se ao servidor através de uma predefinição no config.toml (ou o fornecedor llamacpp); desative a telemetria e as atualizações para uso offline