Tutorial Llama 4 Scout y Maverick en Ollama local: instalación, hardware y flujo profesional paso a paso (agosto 2026)

Ejecutar Llama 4 Scout y Maverick en local con Ollama pasó de ser un experimento de fin de semana a una decisión estratégica en agosto de 2026. Con Ollama 0.32.8 recién publicado, soporte estable para arquitectura MoE (Mixture of Experts) y drivers CUDA 12.6 y ROCm 7.1 maduros, cualquier estación de trabajo bien dimensionada puede servir un modelo de 17B parámetros activos con contexto de 10 millones de tokens sin depender de una API remota. Este tutorial recorre los diez pasos exactos que necesitas: elegir la variante correcta según tu hardware, instalar Ollama en Windows, macOS y Linux, tirar del modelo, exprimir la GPU, exponer un endpoint REST, integrar con Python y LangChain, crear un Modelfile propio y desplegarlo en producción con Docker Compose y telemetría OpenTelemetry.

Por qué ejecutar Llama 4 local en agosto de 2026

Meta liberó Llama 4 en abril de 2026 con dos pesos abiertos que cubren extremos opuestos del espectro: Scout (17B parámetros activos, 109B totales, 16 expertos MoE, contexto de 10 millones de tokens) y Maverick (17B activos, 400B totales, 128 expertos, contexto de 1 millón). Cuatro meses después la comunidad ya empujó ambos modelos a hardware que era impensable para modelos densos equivalentes gracias al enrutado MoE: solo se activan dos expertos por token, así que la memoria total del modelo no se recorre en cada paso.

Los motivos para bajar del cloud a tu propio equipo en 2026 son cuatro: coste marginal cero por token una vez amortizado el hardware, privacidad total sobre datos sensibles (imprescindible para bufetes, clínicas y equipos de RGPD estricto), latencia consistente sin picos por congestión regional y libertad para hacer fine-tuning ligero con LoRA o Modelfiles propios sin subir corpus. Si ya cubriste los fundamentos de Ollama en nuestra guía general, este tutorial es el siguiente paso natural.

Requisitos hardware por variante de Llama 4

Elegir la variante equivocada arruina la experiencia: Scout en un portátil de 8 GB va a swapear a disco y devolver un token cada varios segundos, y Maverick en una RTX 4090 sola sin quantizar directamente no arranca. La tabla resume los mínimos reales de agosto de 2026:

Para el 90% de los lectores la configuración de referencia es una estación con CPU moderna, 64 GB de RAM DDR5 y una GPU de 24-32 GB. Nuestro benchmark de referencia usa AMD Ryzen 9 9950X3D con Corsair Vengeance 64 GB DDR5-6000 CL30 y GPU MSI GeForce RTX 5090 32 GB Gaming Trio OC. Alternativamente, un mini PC como el Beelink SER8 32 GB / 1 TB o el MINISFORUM UM790 Pro ejecutan Scout Q4 en CPU pura a 4-6 tokens por segundo, suficiente para tareas asíncronas.

Si prefieres Apple Silicon, un MacBook Pro M4 14" con 36 GB unified memory saca Scout a 22-28 tokens por segundo con quantización Q4. Para Maverick necesitas subir a Mac Studio M4 Max con 128 GB. En almacenamiento, un Samsung 990 Pro 2 TB NVMe o el Kingston Fury Renegade 4 TB Gen4 son el mínimo si vas a jugar con varios modelos: cada shard de Maverick pasa de los 200 GB.

Paso 1: Elegir Scout o Maverick según el caso de uso

Antes de escribir un solo comando conviene decidir con qué variante vas a trabajar. La regla que aplicamos en Arkaia es: Scout por defecto, Maverick solo si el caso de uso lo justifica. Scout resuelve el 95% de las tareas de RAG, resumen, clasificación y generación de código en español y, sobre todo, aprovecha el contexto de 10M tokens (nadie más lo tiene abierto en agosto de 2026). Maverick brilla cuando hace falta razonamiento matemático profundo o multimodalidad avanzada con imagen y vídeo, pero paga la factura en VRAM y latencia.

# Chequeo rapido de recursos antes de decidir
nvidia-smi --query-gpu=name,memory.total --format=csv
free -h
df -h /var/lib/ollama

Trampa comun: la gente mira solo la VRAM total y olvida el overhead del sistema. Ollama necesita ~2 GB extra para el KV cache y activaciones. En una RTX 4090 de 24 GB reales quedan 22 GB para el modelo, que es exactamente el limite de Scout Q4_K_M. Si tienes el escritorio conectado a la misma GPU pierdes otros 500 MB.

Paso 2: Instalación de Ollama en Windows, macOS y Linux

Ollama 0.32.8 (10 agosto 2026) es la versión estable actual e incluye soporte nativo MLX en Apple Silicon (aceleración adicional del 15-20% frente a Metal puro), Flash Attention activada por defecto y soporte de imagen para modelos multimodales. Las tres rutas de instalación:

# Windows (PowerShell como administrador)
winget install Ollama.Ollama

# macOS (Homebrew o descarga directa)
brew install --cask ollama
# alternativa: https://ollama.com/download/Ollama-darwin.zip

# Linux (script oficial, detecta CUDA/ROCm automaticamente)
curl -fsSL https://ollama.com/install.sh | sh

# Verifica version
ollama --version
# Salida esperada: ollama version is 0.32.8

En Linux con GPU NVIDIA asegúrate de tener drivers 555 o superiores y el toolkit CUDA 12.6. Para AMD el mínimo es ROCm 7.1 (soporte RDNA 3 y RDNA 4 estable). El instalador crea un servicio systemd (ollama.service) que arranca en 127.0.0.1:11434. Compruébalo con systemctl status ollama.

Trampa común: en WSL2 el instalador Linux funciona, pero no ve la GPU si no exportas CUDA_VISIBLE_DEVICES=0 y activas el paso-through NVIDIA en .wslconfig. Verifica siempre con nvidia-smi dentro de WSL antes de tirar el modelo.

Paso 3: Pull del modelo Scout desde el registry oficial

El registry de Ollama sirve las variantes de Llama 4 con nomenclatura expertos x parametros_activos. Scout es llama4:16x17b y Maverick es llama4:128x17b. Sin sufijo explícito Ollama elige la quantización Q4_K_M (equilibrio calidad/tamaño).

# Pull Scout Q4_K_M (unos 67 GB, pon una conexion decente)
ollama pull llama4:16x17b

# Variantes especificas (opcional)
ollama pull llama4:16x17b-q8_0        # calidad casi FP16, pesa 117 GB
ollama pull llama4:16x17b-instruct    # alias del chat fine-tuned

# Verifica que quedo en local
ollama list
# NAME                    SIZE      MODIFIED
# llama4:16x17b           67 GB     2 minutes ago

La descarga usa protocol OCI (mismo formato que las imágenes Docker) y soporta reanudación. Si se corta, vuelve a lanzar el ollama pull y retoma en el chunk exacto donde se detuvo. Los pesos quedan en /usr/share/ollama/.ollama/models en Linux o ~/.ollama/models en macOS y Windows.

Trampa común: si tu partición del sistema es pequeña, cambia la ubicación antes del primer pull exportando OLLAMA_MODELS=/mnt/nvme/ollama. Moverlos después obliga a reiniciar el servicio y reimportar. Un NVMe rápido como el Samsung 990 Pro reduce el tiempo de carga inicial del modelo de 40 a 8 segundos.

Paso 4: Primera inferencia interactiva

Con el modelo tirado, la prueba de humo son 30 segundos:

ollama run llama4:16x17b

>>> Resume en tres viñetas la diferencia entre RAG y fine-tuning para un CTO.

- RAG inyecta contexto externo en tiempo de inferencia; el modelo base no cambia.
- Fine-tuning ajusta pesos del modelo con un corpus propio; requiere entrenamiento y evaluacion.
- Coste RAG: infraestructura vector DB; coste fine-tuning: cómputo GPU horas y curado del dataset.

La primera respuesta tarda 3-5 segundos porque Ollama carga el modelo en memoria (cold start). Las siguientes son instantáneas mientras el proceso siga vivo. En RTX 5090 con Scout Q4 vas a ver 55-70 tokens por segundo; en RTX 4090 unos 40-50; en Mac Studio M4 Max 128 GB con Maverick Q4 rondas los 12-15 tok/s.

Paso 5: Optimización GPU, CPU y flash attention

Por defecto Ollama es conservador y a veces reparte capas entre CPU y GPU aunque quepan enteras en VRAM. Fuérzalo con variables de entorno:

# Descarga TODAS las capas a GPU (99 = todas las disponibles)
export OLLAMA_NUM_GPU=99

# Flash Attention (por defecto ON desde 0.22, verifica)
export OLLAMA_FLASH_ATTENTION=1

# KV cache en FP8 para ahorrar VRAM en contextos largos
export OLLAMA_KV_CACHE_TYPE=q8_0

# Numero de peticiones paralelas (default 1)
export OLLAMA_NUM_PARALLEL=4

# Reinicia el servicio para que tome los env vars
sudo systemctl restart ollama

# Verifica que el modelo esta 100% en GPU
ollama ps
# NAME           SIZE     PROCESSOR    UNTIL
# llama4:16x17b  22 GB    100% GPU     4 minutes from now

La combinación de KV cache en FP8 y Flash Attention permite meter contextos de 200K tokens en 24 GB de VRAM sin OOM. Sin esas dos flags Scout se limita a ~32K tokens efectivos. Si trabajas con documentos largos (nuestro caso en optimización de prompts con DSPy), es la diferencia entre poder inyectar el corpus entero o no.

Trampa común: OLLAMA_NUM_PARALLEL=4 multiplica el KV cache por 4. Si vas justo de VRAM, déjalo en 1 o 2. La ganancia real de paralelismo solo aparece con más de 16 GB libres tras cargar el modelo.

Paso 6: Modo servidor REST con endpoint HTTP

Ollama corre siempre como servidor HTTP; el binario CLI es solo un cliente. Puedes atacarlo desde cualquier lenguaje con curl:

# Chat con streaming (default)
curl http://localhost:11434/api/chat -d '{
  "model": "llama4:16x17b",
  "messages": [
    {"role": "system", "content": "Responde en espanol tecnico y conciso."},
    {"role": "user", "content": "Explica MoE en LLMs en 4 lineas."}
  ],
  "stream": true,
  "options": {"temperature": 0.3, "num_ctx": 32768}
}'

# Generate (completion clasica)
curl http://localhost:11434/api/generate -d '{
  "model": "llama4:16x17b",
  "prompt": "def fibonacci(n):",
  "stream": false
}'

El endpoint es compatible por debajo con la especificación OpenAI en /v1/chat/completions, así que cualquier SDK de OpenAI funciona apuntando a http://localhost:11434/v1 con una API key ficticia. Esto es útil para migrar código existente sin tocarlo.

Para exponer Ollama a otras máquinas de la LAN (o a un contenedor) exporta OLLAMA_HOST=0.0.0.0:11434 antes de arrancar el servicio. Nunca lo abras a internet directo sin nginx delante con autenticación básica y rate limiting.

Paso 7: Cliente Python nativo con la librería ollama

La librería oficial ollama es un wrapper delgado sobre el REST que añade tipado y streaming iterable:

pip install ollama

import ollama

# Chat simple
respuesta = ollama.chat(
    model="llama4:16x17b",
    messages=[
        {"role": "system", "content": "Eres un asistente experto en Python."},
        {"role": "user", "content": "Escribe una funcion async que consulte 10 URLs en paralelo."},
    ],
    options={"temperature": 0.2, "num_predict": 512},
)
print(respuesta["message"]["content"])

# Streaming (iterador sincrono)
for chunk in ollama.chat(
    model="llama4:16x17b",
    messages=[{"role": "user", "content": "Cuenta hasta 20 en catalan"}],
    stream=True,
):
    print(chunk["message"]["content"], end="", flush=True)

Para procesamiento por lotes usa asyncio con el cliente asíncrono ollama.AsyncClient(), que permite mantener 4-8 peticiones concurrentes sin bloquear el event loop. Combinado con OLLAMA_NUM_PARALLEL=4 del paso 5, escalas linealmente hasta saturar la GPU.

Paso 8: Integración con LangChain y LlamaIndex

LangChain expone Ollama como cualquier ChatModel de la familia:

pip install langchain langchain-ollama langchain-community

from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOllama(
    model="llama4:16x17b",
    temperature=0.3,
    num_ctx=32768,
    base_url="http://localhost:11434",
)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Analiza el sentimiento del texto y devuelve JSON con label y confidence."),
    ("human", "{texto}"),
])

cadena = prompt | llm | StrOutputParser()
salida = cadena.invoke({"texto": "El servicio ha sido decepcionante y muy lento."})
print(salida)

Combinado con un vector store local (Chroma, Qdrant o LanceDB) tienes un RAG 100% offline. Si vienes del ecosistema Anthropic, la migración conceptual es idéntica a la que vimos en nuestro tutorial de Claude Agent SDK: cambias el ChatModel y el resto de la pipeline no se toca.

Paso 9: Modelfile custom con system prompt y parámetros propios

Un Modelfile es a Ollama lo que un Dockerfile a Docker: una receta declarativa que crea una "imagen" personalizada del modelo base con system prompt fijo, temperatura, contexto y hasta ficheros adjuntos.

cat > Modelfile <<'EOF'
FROM llama4:16x17b

PARAMETER temperature 0.2
PARAMETER num_ctx 65536
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.05

SYSTEM """
Eres Arkaia-Assist, un asistente tecnico del blog Arkaia.
Respondes SIEMPRE en espanol con tildes correctas.
Citas fuentes cuando das cifras concretas.
Si no sabes algo, lo dices en una linea y ofreces alternativa.
"""
EOF

# Compila la imagen local
ollama create arkaia-assist -f Modelfile

# Uso identico al modelo base
ollama run arkaia-assist "Que es MoE en un LLM?"

Los Modelfiles son la forma limpia de mantener versiones internas del asistente sin duplicar código en cada aplicación. Se pueden versionar en git (son texto plano) y compartir por el registry privado con ollama push.

Paso 10: Producción con Docker Compose y monitoring OpenTelemetry

Para servir Llama 4 en un servicio interno lo montamos como stack Docker Compose con contenedor Ollama, un pequeño gateway FastAPI que añade autenticación y logging, y un colector OpenTelemetry que exporta métricas y trazas a un Grafana Tempo o a un backend gestionado.

version: "3.9"
services:
  ollama:
    image: ollama/ollama:0.32.8
    runtime: nvidia
    environment:
      - OLLAMA_NUM_GPU=99
      - OLLAMA_FLASH_ATTENTION=1
      - OLLAMA_KV_CACHE_TYPE=q8_0
      - OLLAMA_NUM_PARALLEL=4
      - OLLAMA_HOST=0.0.0.0:11434
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  gateway:
    build: ./gateway
    environment:
      - OLLAMA_URL=http://ollama:11434
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4317
      - OTEL_SERVICE_NAME=llama4-gateway
    ports:
      - "8080:8080"
    depends_on: [ollama, otel-collector]

  otel-collector:
    image: otel/opentelemetry-collector-contrib:0.106.0
    command: ["--config=/etc/otel-collector.yaml"]
    volumes:
      - ./otel-collector.yaml:/etc/otel-collector.yaml

volumes:
  ollama_data:

# gateway/main.py — FastAPI + fallback a API remota
import os, httpx
from fastapi import FastAPI, HTTPException
from opentelemetry import trace
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor

app = FastAPI()
FastAPIInstrumentor.instrument_app(app)
tracer = trace.get_tracer("llama4-gateway")

OLLAMA = os.getenv("OLLAMA_URL", "http://ollama:11434")
FALLBACK = os.getenv("FALLBACK_API_URL")  # p.ej. Claude o GPT como red de seguridad

@app.post("/chat")
async def chat(payload: dict):
    with tracer.start_as_current_span("llama4.chat") as span:
        span.set_attribute("model", payload.get("model", "llama4:16x17b"))
        try:
            async with httpx.AsyncClient(timeout=60) as client:
                r = await client.post(f"{OLLAMA}/api/chat", json=payload)
                r.raise_for_status()
                return r.json()
        except Exception as e:
            span.record_exception(e)
            if FALLBACK:
                # degradacion controlada a API remota
                return {"fallback": True, "error": str(e)}
            raise HTTPException(503, "Ollama no disponible")

Con esta arquitectura ganas trazabilidad end-to-end (cada petición lleva su span con tokens generados, latencia y modelo usado), degradación controlada si el nodo Ollama cae y aislamiento de red que no expone el puerto 11434 hacia fuera. En Arkaia servimos Arisa (el bot de la comunidad) con este mismo patrón sobre Gemma 3, y migrar a Llama 4 Scout supuso cambiar dos líneas del compose.

Alternativas a Ollama: LM Studio, llama.cpp y vLLM

Ollama gana por comodidad, pero no es la única opción. Para escenarios concretos vale la pena conocer las alternativas:

• LM Studio: GUI de escritorio para Windows, macOS y Linux. Ideal para explorar modelos sin tocar terminal, con MMLU integrado y visor de embeddings. Rendimiento equivalente a Ollama porque comparten backend llama.cpp.
• llama.cpp directo: el motor C++ que hay debajo de todo. Máxima flexibilidad y últimas optimizaciones (soporte de cuantizaciones exóticas como IQ2_XS o IQ1_M días antes que Ollama). Curva de aprendizaje mayor y sin gestión de modelos.
• vLLM: pensado para servir a muchos usuarios simultáneos con PagedAttention. Necesita GPU con al menos 40 GB (H100, A100, MI300). Overkill para 1-4 usuarios pero imprescindible en producción con cientos de peticiones por segundo.
• MLX (Apple Silicon): framework nativo Apple. Ollama ya lo usa internamente en macOS desde 0.31, así que rara vez toca bajar a MLX directo.

Para desarrollo diario y equipos pequeños Ollama es la elección por defecto en 2026. Cuando el uso crezca por encima de 20 peticiones concurrentes sostenidas, migra a vLLM en un servidor dedicado y deja Ollama para desarrollo local. Si estás considerando invertir en Apple Silicon, léete nuestro análisis del Mac Studio M5 Ultra para IA local antes de decidir entre CUDA y MLX.

Casos de uso reales con Llama 4 local

En agosto de 2026 los patrones que mejor rinden con Scout y Maverick en local son cuatro y merece la pena ver cómo se implementa cada uno con el stack que hemos montado en los pasos anteriores:

1. RAG privado sobre documentación interna: Scout con contexto 200K permite meter una wiki entera de 500 páginas sin trocear. Vector store Chroma, embeddings nomic-embed-text (también servido por Ollama) y prompt template estructurado. Latencia p95 de 4 segundos por respuesta. La ventaja crítica frente a un RAG con Claude o GPT remoto es que el corpus permanece cifrado en reposo y en tránsito dentro de la máquina; el auditor RGPD lo aprueba sin exigir cláusulas de subprocessing con terceros extracomunitarios.
2. Code review asistido: hook de git pre-push que pasa el diff por Scout con Modelfile especializado en el stack del equipo (Python + FastAPI, o TypeScript + Next.js, según el repo). Detecta bugs típicos, dependencias sin actualizar y patrones bloqueantes async antes de que suban a CI. Configurado bien reduce un 30-40% las rondas de revisión humana en PRs pequeñas.
3. Chat privado con LOPD estricto: bufetes y clínicas usan Maverick en Mac Studio M4 Max local para consultas sobre expedientes sin que ningún token salga de la red interna. Cumplimiento RGPD Art. 32 sobre la marcha. El coste hardware inicial se amortiza en 6-9 meses contra el coste de un contrato empresa con proveedor cloud europeo homologado.
4. Fine-tuning ligero por dominio: LoRA de 100-500 ejemplos etiquetados a mano ajustan Scout para tareas de clasificación específicas en español técnico (agricultura, legal, sanidad). Entrenamiento en 40 minutos en una RTX 5090 con Unsloth 2026.5. Al final del proceso exportas a GGUF y lo cargas de vuelta en Ollama con un ollama create dominio-especializado -f Modelfile, y el resto de la aplicación sigue apuntando al mismo endpoint HTTP sin ningún cambio.

Los cuatro patrones comparten una propiedad interesante: el coste marginal por petición es electricidad, no dinero por token. Una workstation con RTX 5090 al 100% de carga consume unos 600-700 W: menos de 15 céntimos de euro por hora de inferencia intensiva. Contra los 8-12 dólares que costaría procesar el mismo volumen con Claude Opus o GPT-4o, la ecuación se hace obvia por encima de las 200-300 peticiones diarias sostenidas.

Recursos, libros y hardware recomendado

Para consolidar lo aprendido, tres libros que están en la mesa de la redacción de Arkaia y que recomendamos sin reservas:

• AI Engineering (Chip Huyen, O'Reilly, 2025): el libro definitivo para pasar prototipos de LLM a producción. Capítulos sobre observabilidad, evaluación y deployment aplican directo al stack que montamos en el paso 10.
• Hands-On Machine Learning con Scikit-Learn, Keras y TensorFlow (Aurélien Géron, 3ª ed.): para entender qué hace por dentro un modelo antes de servirlo con Ollama.
• Fluent Python (Luciano Ramalho, 2ª ed.): imprescindible para escribir los gateways asíncronos del paso 10 sin dispararse en el pie con asyncio.

En el frente hardware, si vas a montar la workstation desde cero, además del combo CPU + RAM + GPU y NVMe ya citados, no descuides los periféricos. Sesiones de 8 horas escribiendo Modelfiles y depurando prompts machacan las muñecas: un Logitech MX Master 3S, un teclado Keychron K8 Pro RGB y un monitor de calidad como el LG UltraGear 32GS95UE OLED 4K hacen más diferencia diaria de la que parece. Y una silla IKEA Markus o, si el presupuesto lo permite, una Secretlab TITAN Evo son el requisito silencioso para cualquier proyecto largo.

Preguntas frecuentes (FAQ)

Conclusión: Llama 4 local, herramienta seria en agosto de 2026

La combinación de Ollama 0.32.8, arquitectura MoE de Llama 4 y hardware consumer de 2026 hace que ejecutar un modelo con 10 millones de tokens de contexto en tu propia máquina sea rutina y no proeza. Los diez pasos de este tutorial cubren desde la instalación inicial hasta un despliegue con observabilidad, y cada bloque de código es directamente ejecutable. El siguiente paso natural es integrar Scout con tu pipeline de RAG, tus agentes o tu editor: la base ya está montada.

Nuestra recomendación operativa en Arkaia para agosto de 2026 es empezar por Scout Q4 en la mejor GPU consumer que puedas presupuestar, montar el gateway del paso 10 desde el primer día (aunque tenga un solo usuario) y añadir observabilidad OpenTelemetry incluso en desarrollo: cuando llegue el momento de escalar, el paso a vLLM o a un cluster multi-GPU es mecánico porque el resto de la aplicación ya trata con un endpoint HTTP estable. Si este tutorial te fue útil, tenemos ya en cola un análisis a fondo sobre estrategias de fine-tuning barato con LoRA sobre Scout y una comparativa Llama 4 frente a Qwen 3 y Mistral Nemotron 2026 que sale la semana que viene.