Mistral Small 3.1

Despliega Mistral Small 3.1 (24B) en Clore.ai — el modelo de producción ideal para una sola GPU

Mistral Small 3.1, lanzado en marzo de 2025 por Mistral AI, es un modelo denso de 24 mil millones de parámetros que rinde mucho más de lo que su tamaño indica. Con una ventana de contexto de 128K, capacidades de visión nativas, llamadas a funciones de primera clase y un Licencia Apache 2.0, es posiblemente el mejor modelo que puedes ejecutar en una sola RTX 4090. Supera a GPT-4o Mini y Claude 3.5 Haiku en la mayoría de los benchmarks mientras cabe cómodamente en hardware de consumo cuando se cuantiza.

Características clave

• 24B parámetros densos — sin la complejidad MoE, implementación sencilla

• Ventana de contexto de 128K — puntaje RULER 128K de 81.2%, supera a GPT-4o Mini (65.8%)

• Visión nativa — analiza imágenes, gráficos, documentos y capturas de pantalla

• Licencia Apache 2.0 — totalmente abierto para uso comercial y personal

• Llamadas a funciones de élite — uso nativo de herramientas con salida JSON, ideal para flujos de trabajo agentivos

• Multilingüe — más de 25 idiomas incluyendo CJK, árabe, hindi y lenguas europeas

Requisitos

Componente	Cuantizado (Q4)	Precisión completa (BF16)
GPU	1× RTX 4090 24GB	2× RTX 4090 o 1× H100
VRAM	~16GB	~55GB
RAM	32GB	64GB
Disco	20GB	50GB
CUDA	11.8+	12.0+

recomendación de Clore.ai: RTX 4090 (~$0.5–2/día) para inferencia cuantizada — mejor relación precio/rendimiento

Inicio rápido con Ollama

La forma más rápida de poner en marcha Mistral Small 3.1:

# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Ejecutar Mistral Small 3.1 (descarga automática ~14GB de cuantización Q4)
ollama run mistral-small3.1

# O especificar una cuantización específica
ollama run mistral-small3.1:24b-instruct-2503-q4_K_M

Ollama como API compatible con OpenAI

# Iniciar el servidor Ollama
ollama serve &

# Descargar el modelo
ollama pull mistral-small3.1

# Consultar vía API
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small3.1",
    "messages": [
      {"role": "system", "content": "Eres un asistente de programación servicial."},
      {"role": "user", "content": "Escribe un decorador en Python para limitar la tasa"}
    ],
    "temperature": 0.15
  }'

Ollama con Visión

# Enviar una imagen para análisis
curl http://localhost:11434/api/chat -d '{
  "model": "mistral-small3.1",
  "messages": [{
    "role": "user",
    "content": "¿Qué muestra esta imagen?",
    "images": ["/ruta/a/la/imagen.jpg"]
  }]
}'

Configuración de vLLM (Producción)

Para cargas de trabajo de producción con alto rendimiento y solicitudes concurrentes:

# Instalar vLLM (se requiere v0.8.1+)
pip install -U vllm

# Verificar que mistral_common esté instalado (debería ser automático)
python -c "import mistral_common; print(mistral_common.__version__)"

Servir en GPU única (solo texto)

vllm serve mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

Servir con Visión (se recomiendan 2 GPUs)

vllm serve mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --limit-mm-per-prompt 'image=10' \
  --tensor-parallel-size 2 \
  --max-model-len 65536

Consultar el servidor

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    messages=[
        {"role": "system", "content": "Eres un asistente útil. Hoy es 2026-02-20."},
        {"role": "user", "content": "Escribe una API REST completa en FastAPI con operaciones CRUD para un blog"}
    ],
    temperature=0.15,
    max_tokens=4096
)
print(response.choices[0].message.content)

HuggingFace Transformers

Para integración directa en Python y experimentación:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # cuantización a 4 bits — cabe en GPU de 24GB
)

messages = [
    {"role": "system", "content": "Eres un asistente de programación servicial."},
    {"role": "user", "content": "Implementa un árbol binario de búsqueda en Python con métodos insert, delete y search"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

output = model.generate(
    input_ids,
    max_new_tokens=2048,
    temperature=0.15,
    do_sample=True
)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))

Ejemplo de llamadas a funciones

Mistral Small 3.1 es uno de los mejores modelos pequeños para el uso de herramientas:

import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Obtener el precio de la acción actual para un símbolo ticker dado",
            "parameters": {
                "type": "object",
                "required": ["ticker"],
                "properties": {
                    "ticker": {"type": "string", "description": "Símbolo bursátil (por ejemplo, AAPL)"}
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_portfolio_value",
            "description": "Calcular el valor total de la cartera dadas las participaciones",
            "parameters": {
                "type": "object",
                "required": ["holdings"],
                "properties": {
                    "holdings": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "ticker": {"type": "string"},
                                "shares": {"type": "number"}
                            }
                        }
                    }
                }
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    messages=[{"role": "user", "content": "¿Cuál es el precio actual de AAPL y MSFT?"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.15
)

for tool_call in response.choices[0].message.tool_calls:
    print(f"Call: {tool_call.function.name}({tool_call.function.arguments})")

Inicio rápido con Docker

# Implementación en GPU única
docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 32768

# Con soporte de visión (2 GPUs)
docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-Small-3.1-24B-Instruct-2503 \
  --tokenizer-mode mistral \
  --config-format mistral \
  --load-format mistral \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --limit-mm-per-prompt 'image=10' \
  --tensor-parallel-size 2

Consejos para usuarios de Clore.ai

• RTX 4090 es el punto ideal: A $0.5–2/día, una sola RTX 4090 ejecuta Mistral Small 3.1 cuantizado con margen. Mejor relación costo/rendimiento en Clore.ai para un LLM de propósito general.

• Usar baja temperatura: Mistral AI recomienda temperature=0.15 para la mayoría de las tareas. Temperaturas más altas provocan salida inconsistente con este modelo.

• RTX 3090 también funciona: A $0.3–1/día, la RTX 3090 (24GB) ejecuta Q4 cuantizado con Ollama sin problemas. Un poco más lenta que la 4090 pero a la mitad de precio.

• Ollama para configuraciones rápidas, vLLM para producción: Ollama te da un modelo funcionando en 60 segundos. Para solicitudes API concurrentes y mayor rendimiento, cambia a vLLM.

• Las llamadas a funciones la hacen especial: Muchos modelos de 24B pueden chatear — pocos pueden llamar herramientas de manera fiable. Las llamadas a funciones de Mistral Small 3.1 están a la par con GPT-4o Mini. Construye agentes, backends de API y pipelines de automatización con confianza.

Solución de problemas

Problema	Solución
OutOfMemoryError en RTX 4090	Usa el modelo cuantizado vía Ollama o load_in_4bit=True en Transformers. BF16 completo necesita ~55GB.
Modelo de Ollama no encontrado	Usa ollama run mistral-small3.1 (nombre oficial de la biblioteca).
Errores del tokenizador de vLLM	Siempre pasa --tokenizer-mode mistral --config-format mistral --load-format mistral.
Mala calidad de salida	Establecer temperature=0.15. Añade un prompt de sistema. Mistral Small es sensible a la temperatura.
Visión no funciona en 1 GPU	Las funciones de visión necesitan más VRAM. Usa --tensor-parallel-size 2 o reduce --max-model-len.
Las llamadas a funciones devuelven vacío	Agregar --tool-call-parser mistral --enable-auto-tool-choice para vLLM serve.

Lecturas adicionales

• Mistral Small 3.1 en HuggingFace

• Entrada del blog de Mistral AI

• Página del modelo en Ollama

• Documentación vLLM

• Biblioteca Mistral Common

• Plataforma Mistral AI