Guía de inicio rápido de Devstral: Ejecuta localmente el LLM de Mistral AI

Parece que los nuevos modelos de IA llegan a un ritmo vertiginoso, y Mistral AI se ha sumado a la emoción con el lanzamiento de Devstral, un innovador modelo de codificación de código abierto. Devstral es un gran modelo de lenguaje (LLM) de codificación Agentic que puede ejecutarse localmente en una GPU RTX 4090 o en un Mac con 32 GB de RAM, lo que lo hace accesible para su despliegue local y su uso en el dispositivo. Es rápido, preciso y fácil de usar. 

En este tutorial, aprenderemos todo lo que necesitas saber sobre Devstral, incluidas sus principales características y lo que lo hace único. También aprenderemos a ejecutar Devstral localmente utilizando herramientas como Mistral Chat CLI y a integrar la API Mistral AI con OpenHands para probar las capacidades agénticas de Devstral.

Puedes obtener más información sobre otras herramientas de Mistral en guías separadas, incluyendo Mistral Medio 3, API Mistral OCRy Mistral Le Chat.

¿Qué es Mistral Devstral?

Devstral es un modelo agéntico de última generación diseñado para tareas de ingeniería de software. Ha sido desarrollado por Mistral AI en colaboración con All Hands AI. Destaca en la resolución de retos de codificación del mundo real, como explorar grandes bases de código, editar múltiples archivos y resolver problemas en el repositorio de GitHub. 

El rendimiento de Devstral en la prueba SWE-Bench Verified es inigualable, con una puntuación del 46,8%, lo que lo sitúa como el modelo de código abierto nº 1 en esta prueba, superando en un 6% a los modelos anteriores de última generación.

Fuente: Devstral | Mistral AI

Construido sobre Mistral-Small-3.1, Devstral dispone de una ventana contextual de 128k, lo que le permite procesar y comprender grandes cantidades de código y dependencias. A diferencia de su modelo base, Devstral es sólo texto, ya que el codificador de visión se eliminó durante el ajuste fino para especializarlo en tareas de codificación. 

Su capacidad para trabajar a la perfección con herramientas como OpenHands le permite superar incluso a modelos mucho mayores, como Deepseek-V3-0324 (671B) y Qwen3 232B-A22B.

Características principales de Devstral

He aquí algunas características notables de Devstral que lo diferencian de otros modelos de codificación.

1. Codificación antigénica

Devstral está diseñado específicamente para sobresalir en las tareas de codificación agéntica, lo que lo convierte en un modelo ideal para construir y desplegar agentes de ingeniería de software. Su capacidad para resolver tareas complejas de varios pasos dentro de grandes bases de código permite a los programadores abordar con eficacia los retos de codificación del mundo real.

2. Diseño ligero

Una de las características más destacadas de Devstral es su arquitectura ligera. Con sólo 24.000 millones de parámetros, puede ejecutarse en una única GPU Nvidia RTX 4090. Esta característica lo hace ideal para el despliegue local, el uso en el dispositivo y las aplicaciones sensibles a la privacidad.

3. Código abierto 

Publicado bajo la licencia Apache 2.0, Devstral está disponible gratuitamente para uso comercial. Los programadores y las organizaciones pueden implantarlo, modificarlo e incluso integrarlo en productos propios sin restricciones.

4. Ventana contextual ampliada

Devstral dispone de una impresionante ventana contextual de 128k, lo que le permite procesar y comprender grandes cantidades de código e instrucciones en una sola interacción. Esto lo hace especialmente eficaz para trabajar con grandes bases de código y resolver problemas de programación complejos.

5. Tokenizador avanzado

Devstral utiliza un tokenizadorTekken con un vocabulario de 131 k, lo que le permite manejar entradas de código y texto con precisión y eficacia. Este tokenizador mejora la capacidad del modelo para generar respuestas precisas y conscientes del contexto, adaptadas a las tareas de ingeniería de software.

Primeros pasos con Devstral

Devstral se puede descargar gratuitamente en plataformas como Hugging Face, Ollama, Kaggle, Unsloth y LM Studio. Los programadores también pueden acceder a ella a través de la API con el nombre devstral-small-2505 a un precio competitivo: 0,10 $ por millón de tokens de entrada y 0,30 $ por millón de tokens de salida.

En esta guía, cubriremos dos flujos de trabajo clave:

1. Ejecutar Devstral localmente utilizando la inferencia Mistral.
2. Integrando Devstral con OpenHands para construir proyectos de machine learning.

Ejecutar Devstral localmente

Para ejecutar Devstral localmente, utilizaremos una instancia de Runpod con soporte para GPU, descargaremos el modelo de Hugging Face e interactuaremos con él utilizando la herramienta CLI mistral-chat.

1. Configura el pod con 100 GB de almacenamiento y una GPU A100 SXM, y lanza la instancia de JupyterLab.

2. Ejecuta los siguientes comandos en un Jupyter Notebook para instalar las dependencias necesarias:

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

3. Utiliza el Hugging Face Hub para descargar los archivos del modelo, el tokenizador y la configuración de los 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. Abre un terminal en JupyterLab y ejecuta el siguiente comando para iniciar la CLI mistral-chat:

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

5. Prueba el siguiente aviso para comprobar Devstral:

"Crea una API REST desde cero utilizando Python".

El modelo ha generado una respuesta detallada y precisa, una guía paso a paso para construir una API REST utilizando 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
=====================

Ejecutar Devstral con OpenHands

Puedes acceder fácilmente al modelo Devstral a través de la API Mistal AI. En este proyecto, utilizaremos la API Devstral junto con OpenHands para construir nuestro proyecto de machine learning desde cero. OpenHands es una plataforma de código abierto que actúa como tu ingeniero de software de IA para construir y completar tu proyecto de codificación.

1. Visita la plataforma Mistral AI y genera tu clave API.

2. Carga 5 $ en tu cuenta utilizando la tarjeta de débito/crédito. 

3. Ejecuta el siguiente script para 

• Establece la Clave API como variable de entorno.
• Extrae la imagen Docker de OpenHands.
• Crea un archivo de configuración.
• Inicia la aplicación OpenHands en un contenedor 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

La aplicación web estará disponible en 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)

Probar Devstral en OpenHands

1. Pulsa el botón "Iniciar desde cero" para empezar a crear un proyecto.

2.   Se te redirigirá a la nueva interfaz de usuario, que tiene una interfaz de chat y otras pestañas para la inferencia del desarrollo.

3. Utiliza la interfaz del chat para dar indicaciones. En un segundo, Devstral empezará a crear directorios, archivos y código para el proyecto.

4. Cambia a la pestaña Código VS para ver, editar y ejecutar el código generado.

5. Devstral es tan bueno que ha iniciado la aplicación, probando en la aplicación web, y también utiliza el agente web para navegar por la página web.

Una vez completado el proyecto, envíalo a GitHub para compartirlo con tu equipo.

Conclusión

Devstral es una gran noticia para la comunidad del código abierto. Puedes utilizar OpenHands con Ollama o VLLM para ejecutar el modelo localmente y luego interactuar con él a través de la interfaz de usuario de OpenHands. Además, puedes integrar Devstral en tu editor de código mediante extensiones, lo que lo convierte en una opción muy eficaz.

En este tutorial, exploramos Devstral, un modelo de codificación agéntica, y probamos sus capacidades ejecutándolo localmente y utilizando OpenHands. Los resultados fueron impresionantes. Devstral es rápido, muy preciso y destaca en la invocación de agentes para realizar tareas complejas. Su capacidad para afrontar los retos de la ingeniería de software del mundo real con rapidez y precisión lo convierte en una opción destacada para los programadores.

Puedes más información sobre la IA Agenética con el artículo de nuestro blog, y puedes ponerte manos a la obra con nuestro corse, Diseño de Sistemas Agenéticos con LangChain.