Guia de início rápido do Devstral: Execute o LLM da Mistral AI localmente

Parece que novos modelos de IA estão chegando em um ritmo acelerado, e a Mistral AI aumentou a empolgação com o lançamento do Devstral, um modelo inovador de codificação de código aberto. O Devstral é um modelo de linguagem grande (LLM) de codificação Agentic que pode ser executado localmente na GPU RTX 4090 ou em um Mac com 32 GB de RAM, tornando-o acessível para implantação local e uso no dispositivo. Ele é rápido, preciso e fácil de usar. 

Neste tutorial, aprenderemos tudo o que você precisa saber sobre o Devstral, incluindo seus principais recursos e o que o torna único. Também aprenderemos a executar o Devstral localmente usando ferramentas como o Mistral Chat CLI e a integrar a API Mistral AI com o OpenHands para testar os recursos agênticos do Devstral.

Você pode saber mais sobre outras ferramentas da Mistral em guias separados, incluindo Mistral Medium 3, API Mistral OCRe Mistral Le Chat.

O que é o Mistral Devstral?

O Devstral é um modelo agêntico de última geração projetado para tarefas de engenharia de software. Ele foi desenvolvido pela Mistral AI em colaboração com a All Hands AI. Ele se destaca na solução de desafios de codificação do mundo real, como a exploração de grandes bases de código, a edição de vários arquivos e a resolução de problemas no repositório do GitHub. 

O desempenho da Devstral no benchmark SWE-Bench Verified é inigualável, alcançando uma pontuação de 46,8%, o que a posiciona como o modelo de código aberto nº 1 nesse benchmark, superando em 6% os modelos anteriores de última geração.

Fonte: Devstral | Mistral AI

Criado com base no Mistral-Small-3.1, o Devstral apresenta uma janela de contexto de 128k, o que permite que você processe e compreenda grandes quantidades de código e dependências. Diferentemente de seu modelo básico, o Devstral é somente de texto, pois o codificador de visão foi removido durante o ajuste fino para especializá-lo para tarefas de codificação. 

Sua capacidade de trabalhar de forma integrada com ferramentas como OpenHands permite que ele supere até mesmo modelos muito maiores, como o Deepseek-V3-0324 (671B) e o Qwen3 232B-A22B.

Principais recursos do Devstral

Aqui estão alguns recursos notáveis do Devstral que fazem com que ele se destaque de outros modelos de codificação.

1. Codificação autêntica

O Devstral foi projetado especificamente para se destacar em tarefas de codificação agêntica, o que o torna um modelo ideal para a criação e implantação de agentes de engenharia de software. Sua capacidade de resolver tarefas complexas e de várias etapas em grandes bases de código permite que os desenvolvedores enfrentem desafios de codificação do mundo real de forma eficaz.

2. Design leve

Um dos recursos de destaque do Devstral é sua arquitetura leve. Com apenas 24 bilhões de parâmetros, ele pode ser executado em uma única GPU Nvidia RTX 4090. Esse recurso o torna ideal para implantação local, uso no dispositivo e aplicativos sensíveis à privacidade.

3. Código aberto 

Lançado sob a licença Apache 2.0, o Devstral está disponível gratuitamente para uso comercial. Os desenvolvedores e as organizações podem implementar, modificar e até mesmo integrá-lo a produtos proprietários sem restrições.

4. Janela de contexto estendida

O Devstral apresenta uma impressionante janela de contexto de 128k, permitindo que ele processe e compreenda grandes quantidades de código e instruções em uma única interação. Isso o torna particularmente eficaz para trabalhar com grandes bases de código e resolver problemas complexos de programação.

5. Tokenizador avançado

O Devstral usa um tokenizadorTekken com um vocabulário de 131 mil palavras, o que permite que ele manipule entradas de código e texto com precisão e eficiência. Esse tokenizador aprimora a capacidade do modelo de gerar respostas precisas e com reconhecimento de contexto, adaptadas às tarefas de engenharia de software.

Como começar a usar o Devstral

O Devstral está disponível gratuitamente para download em plataformas como Hugging Face, Ollama, Kaggle, Unsloth e LM Studio. Os desenvolvedores também podem acessá-lo via API com o nome devstral-small-2505 a preços competitivos: US$ 0,10 por milhão de tokens de entrada e US$ 0,30 por milhão de tokens de saída.

Neste guia, abordaremos dois fluxos de trabalho principais:

1. Executando o Devstral localmente usando a inferência Mistral.
2. Integrando o Devstral com o OpenHands para que você possa criar projetos de machine learning.

Executando o Devstral localmente

Para executar o Devstral localmente, usaremos uma instância do Runpod com suporte a GPU, faremos o download do modelo do Hugging Face e interagiremos com ele usando a ferramenta CLI do mistral-chat.

1. Configure o pod com 100 GB de armazenamento e a GPU A100 SXM e inicie a instância do JupyterLab.

2. Execute os seguintes comandos em um Jupyter Notebook para instalar as dependências necessárias:

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

3. Use o Hugging Face Hub para fazer download dos arquivos de modelo, do tokenizador e da configuração de parâmetros. 

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. Abra um terminal no JupyterLab e execute o seguinte comando para iniciar a CLI do mistral-chat:

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

5. Experimente o prompt a seguir para testar o Devstral:

"Crie uma API REST do zero usando Python."

O modelo gerou uma resposta detalhada e precisa, um guia passo a passo para você criar uma API REST usando o 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
=====================

Executando o Devstral com o OpenHands

Você pode acessar facilmente o modelo Devstral por meio da API Mistal AI. Neste projeto, usaremos a API Devstral junto com o OpenHands para criar nosso projeto de machine learning desde o início. O OpenHands é uma plataforma de código aberto que funciona como seu engenheiro de software de IA para criar e concluir seu projeto de codificação.

1. Visite a plataforma Mistral AI e gere sua chave de API.

2. Carregue US$ 5 em sua conta usando o cartão de débito/crédito. 

3. Execute o seguinte script para 

• Defina a chave de API como uma variável de ambiente.
• Extraia a imagem do Docker do OpenHands.
• Criar arquivo de configuração.
• Inicie o aplicativo OpenHands em um contêiner do 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

O aplicativo da Web estará disponível em 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)

Testando o Devstral no OpenHands

1. Clique no botão "Launch from Scratch" (Iniciar do zero) para começar a criar um projeto.

2.   Você será redirecionado para a nova interface do usuário, que tem uma interface de bate-papo e outras guias para inferência de desenvolvimento.

3. Use a interface de bate-papo para fornecer avisos. Em um segundo, o Devstral começará a criar diretórios, arquivos e códigos para o projeto.

4. Mude para a guia Código VS para visualizar, editar e executar o código gerado.

5. O Devstral é tão bom que iniciou o aplicativo, testando-o no aplicativo da Web e também usa o agente da Web para navegar na página da Web.

Quando o projeto estiver concluído, envie-o para o GitHub para compartilhá-lo com sua equipe.

Conclusão

O Devstral é uma ótima notícia para a comunidade de código aberto. Você pode usar o OpenHands com Ollama ou VLLM para executar o modelo localmente e interagir com ele por meio da UI do OpenHands. Além disso, você pode integrar o Devstral ao seu editor de código usando extensões, o que o torna uma opção altamente eficaz.

Neste tutorial, exploramos o Devstral, um modelo de codificação agêntica, e testamos seus recursos executando-o localmente e usando o OpenHands. Os resultados foram impressionantes. O Devstral é rápido, altamente preciso e excelente para chamar agentes para executar tarefas complexas. Sua capacidade de lidar com os desafios da engenharia de software do mundo real com velocidade e precisão faz dele uma opção de destaque para os desenvolvedores.

Você pode saber mais sobre Agentic AI com nosso artigo no blog, e você pode colocar a mão na massa com nosso curso, Projetando sistemas agênticos com LangChain.