# Mistral Small 3.1

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:

```bash
# 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

```bash
# 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

```bash
# 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:

```bash
# 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)

```bash
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)

```bash
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

```python
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:

```python
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:

```python
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

```bash
# 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](https://huggingface.co/mistralai/Mistral-Small-3.1-24B-Instruct-2503)
* [Entrada del blog de Mistral AI](https://mistral.ai/news/mistral-small-3-1/)
* [Página del modelo en Ollama](https://ollama.com/library/mistral-small3.1)
* [Documentación vLLM](https://docs.vllm.ai/)
* [Biblioteca Mistral Common](https://github.com/mistralai/mistral-common)
* [Plataforma Mistral AI](https://console.mistral.ai/)