# Mistral Large 3 (675B MoE)

Mistral Large 3 es el modelo de peso abierto más potente de Mistral AI, lanzado en diciembre de 2025 bajo la **Licencia Apache 2.0**. Es un modelo de Mezcla de Expertos (MoE) con 675B parámetros totales pero solo 41B activos por token — ofreciendo rendimiento de vanguardia a una fracción del cálculo de un modelo denso de 675B. Con soporte multimodal nativo (texto + imágenes), una ventana de contexto de 256K y capacidades agenticas de primera clase, compite directamente con modelos tipo GPT-4o y Claude mientras puede alojarse completamente de forma local.

**HuggingFace:** [mistralai/Mistral-Large-3-675B-Instruct-2512](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) **Ollama:** [mistral-large-3:675b](https://ollama.com/library/mistral-large-3) **Licencia:** Apache 2.0

## Características clave

* **675B totales / 41B parámetros activos** — La eficiencia MoE significa que obtienes rendimiento de vanguardia sin activar todos los parámetros
* **Licencia Apache 2.0** — totalmente abierto para uso comercial y personal, sin restricciones
* **Nativamente multimodal** — entiende tanto texto como imágenes a través de un codificador de visión de 2.5B
* **Ventana de contexto de 256K** — maneja documentos masivos, bases de código y conversaciones largas
* **Capacidades agenticas de primera clase** — llamada de funciones nativa, modo JSON, uso de herramientas
* **Múltiples opciones de despliegue** — FP8 en H200/B200, NVFP4 en H100/A100, GGUF cuantizado para GPUs de consumo

## Arquitectura del modelo

| Componente            | Detalles                          |
| --------------------- | --------------------------------- |
| Arquitectura          | Mezcla de Expertos (MoE) granular |
| Parámetros totales    | 675B                              |
| Parámetros activos    | 41B (por token)                   |
| Codificador de visión | 2.5B parámetros                   |
| Ventana de contexto   | 256K tokens                       |
| Entrenamiento         | 3.000× GPUs H200                  |
| Lanzamiento           | Diciembre de 2025                 |

## Requisitos

| Configuración | Presupuesto (Q4 GGUF) | Estándar (NVFP4) | Completo (FP8) |
| ------------- | --------------------- | ---------------- | -------------- |
| GPU           | 4× RTX 4090           | 8× A100 80GB     | 8× H100/H200   |
| VRAM          | 4×24GB (96GB)         | 8×80GB (640GB)   | 8×80GB (640GB) |
| RAM           | 128GB                 | 256GB            | 256GB          |
| Disco         | 400GB                 | 700GB            | 1.4TB          |
| CUDA          | 12.0+                 | 12.0+            | 12.0+          |

**Configuración recomendada de Clore.ai:**

* **Mejor relación calidad-precio:** 4× RTX 4090 (\~$2–8/día) — ejecutar cuantización Q4 GGUF vía llama.cpp u Ollama
* **Calidad de producción:** 8× A100 80GB (\~$16–32/día) — NVFP4 con contexto completo vía vLLM
* **Rendimiento máximo:** 8× H100 (\~$24–48/día) — FP8, contexto completo de 256K

## Inicio rápido con Ollama

La forma más rápida de ejecutar Mistral Large 3 en una instancia Clore.ai con múltiples GPUs:

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

# Ejecuta el modelo 675B (requiere multi-GPU, ~96GB+ VRAM para Q4)
ollama run mistral-large-3:675b

# Para las variantes densas más pequeñas (GPU única):
ollama run mistral3:14b    # 14B denso — cabe en RTX 3060+
ollama run mistral3:8b     # 8B denso — cabe en cualquier GPU
```

## Inicio rápido con vLLM (Producción)

Para servicio de grado de producción con API compatible con OpenAI:

```bash
# Instala vLLM
pip install vllm

# Sirve con cuantización NVFP4 en 8× A100/H100
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral \
    --host 0.0.0.0 \
    --port 8000

# Para FP8 (pesos originales, máxima calidad):
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 131072 \
    --host 0.0.0.0 \
    --port 8000
```

## Ejemplos de uso

### 1. Finalización de chat (API compatible con OpenAI)

Una vez que vLLM esté en funcionamiento, usa cualquier cliente compatible con OpenAI:

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="no-necesaria"
)

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[
        {"role": "system", "content": "Eres un asistente de programación servicial."},
        {"role": "user", "content": "Escribe un scraper web asíncrono en Python usando aiohttp y BeautifulSoup."}
    ],
    temperature=0.1,
    max_tokens=4096
)

print(response.choices[0].message.content)
```

### 2. Llamada de funciones / Uso de herramientas

Mistral Large 3 sobresale en llamadas estructuradas a herramientas:

```python
import json
from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtener el clima actual para una ubicación",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Nombre de la ciudad"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{"role": "user", "content": "¿Cuál es el clima en Tokio?"}],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(f"Function: {tool_call.function.name}")
print(f"Args: {tool_call.function.arguments}")
```

### 3. Visión — Análisis de imágenes

Mistral Large 3 entiende imágenes de forma nativa:

```python
import base64
from openai import OpenAI

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

# Codificar imagen
with open("diagram.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe este diagrama de arquitectura en detalle."},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}}
        ]
    }],
    max_tokens=2048
)

print(response.choices[0].message.content)
```

## Consejos para usuarios de Clore.ai

1. **Comienza con NVFP4 en A100s** — El `Mistral-Large-3-675B-Instruct-2512-NVFP4` el checkpoint está específicamente diseñado para nodos A100/H100 y ofrece calidad casi sin pérdida con la mitad de huella de memoria de FP8.
2. **Usa Ollama para experimentos rápidos** — Si tienes una instancia 4× RTX 4090, Ollama maneja la cuantización GGUF automáticamente. Perfecto para probar antes de comprometerte con una configuración de producción vLLM.
3. **Expón la API de forma segura** — Al ejecutar vLLM en una instancia Clore.ai, usa tunelización SSH (`ssh -L 8000:localhost:8000 root@<ip>`) en lugar de exponer el puerto 8000 directamente.
4. **Reduce `max-model-len` para ahorrar VRAM** — Si no necesitas el contexto completo de 256K, establece `--max-model-len 32768` o `65536` para reducir significativamente el uso de memoria de la caché KV.
5. **Considera las alternativas densas** — Para configuraciones de GPU única, Mistral 3 14B (`mistral3:14b` en Ollama) ofrece un rendimiento excelente en una sola RTX 4090 y es de la misma familia de modelos.

## Solución de problemas

| Problema                         | Solución                                                                                                                                        |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `CUDA fuera de memoria` en vLLM  | Reducir `--max-model-len` (prueba 32768), aumenta `--tensor-parallel-size`, o usa checkpoint NVFP4                                              |
| Velocidad de generación lenta    | Asegúrate de `--tensor-parallel-size` coincida con el número de GPUs; habilita decodificación especulativa con el checkpoint Eagle              |
| Ollama no carga 675B             | Asegúrate de tener 96GB+ de VRAM entre las GPUs; Ollama necesita `OLLAMA_NUM_PARALLEL=1` para modelos grandes                                   |
| `tokenizer_mode mistral` errores | Debes pasar las tres banderas: `--tokenizer-mode mistral --config-format mistral --load-format mistral`                                         |
| La visión no funciona            | Asegúrate de que las imágenes tengan una relación de aspecto cercana a 1:1; evita imágenes muy anchas/estrechas para obtener mejores resultados |
| Descarga demasiado lenta         | Usa `huggingface-cli download mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4` con `HF_TOKEN` establecer                                     |

## Lecturas adicionales

* [Blog de anuncio de Mistral 3](https://mistral.ai/news/mistral-3) — Publicación oficial de lanzamiento con benchmarks
* [Ficha del modelo en HuggingFace](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) — Instrucciones de despliegue y resultados de benchmarks
* [Versión cuantizada NVFP4](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4) — Optimizada para A100/H100
* [GGUF cuantizado (Unsloth)](https://huggingface.co/unsloth/Mistral-Large-3-675B-Instruct-2512-GGUF) — Para llama.cpp y Ollama
* [Documentación vLLM](https://docs.vllm.ai/) — Marco de servicio para producción
* [Guía Day-0 de Red Hat](https://developers.redhat.com/articles/2025/12/02/run-mistral-large-3-ministral-3-vllm-red-hat-ai) — Despliegue vLLM paso a paso


---

# 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-large3.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.