# 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/)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/mistral-small.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.