Ejecutar un modelo de lenguaje local en tu propio equipo es posible en casi cualquier hardware moderno: desde una laptop con procesador Snapdragon X Elite hasta una estación de trabajo con una RTX 4090. El resultado depende menos del hardware y más de saber qué modelo elegir y cómo configurarlo. Esta guía cubre Ollama, LM Studio 0.4.6 y llama.cpp con configuraciones concretas para cada tipo de equipo, desde los más accesibles hasta los más potentes.

Paso 1: identifica tu hardware antes de elegir cualquier modelo

El primer error común es descargar un modelo sin considerar el hardware disponible. El rendimiento de un modelo local depende principalmente de tres factores: la cantidad de memoria disponible (RAM o VRAM), el tipo de procesador y el motor de inferencia que utilizará la herramienta elegida. Conocer estos datos toma menos de un minuto y evita frustraciones.

¿Cómo saber qué hardware tienes?

En Windows:

• Presiona Windows + R, escribe dxdiag y presiona Enter. Verás el procesador, la RAM total y el modelo de GPU.
• En el Administrador de tareas (Ctrl + Shift + Esc), pestaña Rendimiento, puedes ver la memoria de video (VRAM) de tu GPU.

En macOS:

• Menú Apple → Acerca de esta Mac. En chips Apple Silicon (M1, M2, M3, M4), la memoria unificada se comparte entre CPU y GPU.

En Linux:

• Ejecuta lspci | grep -i vga para ver la GPU y free -h para la RAM del sistema.

Mapa de hardware y capacidades reales

La siguiente tabla resume qué esperar de cada tipo de equipo. Los valores de velocidad son aproximados y varían según el modelo y la configuración específica:

¿Qué herramienta usar según tu perfil?

Perfiles de usuario: modelos y configuraciones por hardware

Perfil 1: equipo sin GPU dedicada (solo CPU, 8–16 GB RAM)

Este es el escenario más común en laptops de oficina o equipos económicos. Sin GPU dedicada, la inferencia ocurre completamente en el procesador central, lo que limita el tamaño del modelo a versiones compactas bien cuantizadas. Los resultados son lentos pero funcionales para tareas simples como respuestas a preguntas o resúmenes cortos.

Configuración específica para CPU:

• En llama.cpp, usa –n-gpu-layers 0 para forzar inferencia completa en CPU y –threads 6 (o el número de núcleos físicos de tu procesador menos 2).
• En LM Studio, selecciona CPU only en las opciones de aceleración al cargar el modelo.
• En Ollama, si no hay GPU detectada, el sistema utiliza CPU automáticamente; no requiere configuración adicional.
• Mantén el contexto bajo (2048–4096) para no saturar la RAM con el caché de atención.
• Evita modelos mayores a 4B de parámetros con esta configuración.

Perfil 2: Snapdragon X Elite (laptops ARM con 32–64 GB de RAM)

El Snapdragon X Elite es un caso particular: su CPU ARM de alto rendimiento supera en velocidad de inferencia a muchas GPU dedicadas de gama media para modelos pequeños y medianos. Esto se debe a optimizaciones específicas en llama.cpp para instrucciones ARM (NEON y dotprod) que permiten procesar modelos compactos a 20–35 unidades de texto por segundo. La unidad de procesamiento neuronal integrada (NPU) tiene soporte parcial y experimental en herramientas como LM Studio, principalmente a través del formato ONNX QNN de Qualcomm.

Notas específicas para Snapdragon X Elite:

• Descarga la versión ARM64 de LM Studio desde lmstudio.ai/download; es la versión optimizada para este procesador.
• En llama.cpp compilado para ARM, los modelos Q4_0 se reempaquetan automáticamente al formato acelerado Q4_0_4_4 al cargarse, lo que mejora la velocidad hasta 3 veces en comparación con versiones anteriores.
• El soporte de NPU vía ONNX QNN está disponible de forma experimental a través de herramientas como AnythingLLM; LM Studio todavía lo gestiona principalmente por CPU.
• Con 32 GB de RAM unificada, es posible ejecutar modelos de hasta 13B en Q4 con velocidades aceptables (20–30 unidades/seg).
• Mantén otras aplicaciones cerradas durante la inferencia para evitar competencia por memoria.

Perfil 3: Apple Silicon (M1/M2 con 16 GB — M3/M4 con 32 GB o más)

Apple Silicon tiene una ventaja estructural para inferencia local: su memoria unificada es accesible tanto por la CPU como por la GPU integrada y el motor de inteligencia neural. LM Studio aprovecha esto a través del motor MLX de Apple, que ofrece mayor velocidad que llama.cpp en chips M2 y superiores para modelos medianos. En chips M3/M4 con 32 GB o más, es posible ejecutar modelos de 70B de parámetros con rendimiento práctico.

Notas para Apple Silicon:

• En LM Studio, selecciona modelos con etiqueta MLX en el catálogo para aprovechar el motor optimizado de Apple.
• En Ollama, el soporte Metal está activo de forma automática; no requiere configuración adicional.
• En llama.cpp, compila con -DGGML_METAL=ON o descarga los binarios precompilados para macOS.
• Con menos de 16 GB de memoria unificada, los modelos de 7B en Q4 son el límite práctico.

Perfil 4: GPU NVIDIA 8 GB (RTX 3060, RTX 3070, RTX 4060)

Una GPU de 8 GB de memoria de video es el punto de entrada más común para usuarios entusiastas. Permite ejecutar modelos de hasta 13B de parámetros en cuantización Q4, con velocidades entre 25 y 55 unidades de texto por segundo según el modelo y la configuración. La atención rápida es especialmente importante aquí: activa el soporte para contextos largos sin agotar la memoria de video.

Notas:

• Activa siempre OLLAMA_FLASH_ATTENTION=1 o –flash-attn en llama.cpp para reducir el consumo de VRAM en contextos de más de 4096 unidades de texto.
• Usa OLLAMA_KV_CACHE_TYPE=Q8_0 para cuantizar el caché de contexto y liberar espacio para contextos más amplios.
• En llama.cpp, si el modelo no cabe completamente en GPU, ajusta –n-gpu-layers gradualmente: comienza en 20 y sube de 5 en 5 hasta encontrar el máximo sin errores de memoria.
• Con 8 GB, evita contextos mayores a 8192 sin cuantización del caché de contexto activa.

Perfil 5: GPU NVIDIA 12–16 GB (RTX 4070, RTX 3080, RTX 4070 Ti)

Con 12 a 16 GB de memoria de video es posible ejecutar modelos de hasta 30B de parámetros en cuantización Q4, o modelos de 14B en Q5 con buena calidad. Este rango permite tareas más exigentes como generación de código extenso, análisis de documentos largos o conversaciones con contexto de 16384 unidades de texto o más.

Notas:

• En Ollama, combina OLLAMA_KV_CACHE_TYPE=Q8_0 con OLLAMA_FLASH_ATTENTION=1 para alcanzar contextos de 32768 sin errores de memoria.
• En LM Studio, habilita Use GPU for inference, Auto-split layers y Enable MLock para una configuración estable.
• Con 16 GB de VRAM, un modelo Qwen 14B en Q5_K_M ocupa aproximadamente 11–12 GB, dejando margen para el caché de contexto.

Perfil 6: GPU NVIDIA 24 GB o más (RTX 4090, RTX 3090, RTX A5000)

Con 24 GB de memoria de video es posible ejecutar modelos de 70B de parámetros en cuantización Q4, que ofrecen una calidad de respuesta comparable a modelos comerciales de primera generación. Este es el punto en que la inferencia local se convierte en una alternativa real y práctica para flujos de trabajo profesionales.

Notas:

• En Ollama, OLLAMA_NUM_PARALLEL=8 permite atender múltiples solicitudes simultáneas, útil cuando se conectan varias aplicaciones al servidor local.
• En LM Studio, activa Use NVML para una gestión más precisa de la memoria de video en tarjetas NVIDIA.
• En llama.cpp con dos GPUs, usa –tensor-split 0.5,0.5 para distribuir las capas del modelo equitativamente.
• La cuantización MXFP4 de llama.cpp es experimental y exclusiva para GPUs NVIDIA de arquitectura Blackwell (serie RTX 50XX). No se recomienda para uso general en esta etapa.

Perfil 7: GPU AMD (RX 6800 XT / RX 7900 XTX, 16–24 GB)

Las GPU AMD tienen buen soporte en llama.cpp a través del motor ROCm en Linux y del motor Vulkan tanto en Linux como en Windows. El rendimiento con ROCm es comparable al de CUDA para modelos de tamaño mediano, mientras que Vulkan es funcional pero generalmente más lento. Ollama soporta ROCm de forma nativa en Linux; en Windows el soporte es más limitado.

Notas:

• En llama.cpp con ROCm, compila con -DGGML_HIPBLAS=ON y verifica que tu GPU esté en la lista de arquitecturas soportadas por ROCm (gfx1030 para RX 6800, gfx1100 para RX 7900).
• Para Vulkan en Windows con GPU AMD, descarga los binarios precompilados de llama.cpp que incluyen el motor Vulkan; no requiere instalación adicional de controladores.
• LM Studio tiene soporte Vulkan disponible, aunque con algunas limitaciones en modelos muy grandes; se recomienda probar con cada modelo específico.

Perfil 8: GPU Intel Arc (A770 / B580, 8–16 GB)

Las GPU Intel Arc tienen soporte funcional a través de dos motores en llama.cpp: SYCL (requiere instalar el kit de herramientas oneAPI de Intel) y Vulkan (más sencillo de configurar pero con menor rendimiento). LM Studio también soporta Intel Arc vía Vulkan desde versiones recientes. La velocidad es modesta comparada con NVIDIA a igual cantidad de VRAM, pero suficiente para modelos de hasta 13B con uso práctico.

Notas:

• Para SYCL en llama.cpp, instala el kit oneAPI Base Toolkit de Intel y compila llama.cpp con -DGGML_SYCL=ON.
• El motor Vulkan es más sencillo de activar pero puede mostrar velocidades 20–40% menores que SYCL en la misma GPU.
• Mantén el contexto en 4096 o menos con este hardware para evitar problemas de memoria.

Configuración detallada por herramienta

¿Cómo configurar Ollama desde cero?

Ollama es ideal para integrar modelos locales con aplicaciones de terceros gracias a su API compatible con el formato OpenAI. Su configuración se realiza mediante variables de entorno y archivos Modelfile. Por defecto, Ollama descarga el modelo de memoria tras 5 minutos de inactividad; este comportamiento es ajustable con OLLAMA_KEEP_ALIVE.

Variables de entorno esenciales:

• OLLAMA_FLASH_ATTENTION=1: activa la atención rápida; reduce el consumo de memoria en contextos largos.
• OLLAMA_KV_CACHE_TYPE=Q8_0: cuantiza el caché de atención para ahorrar memoria de video.
• OLLAMA_KEEP_ALIVE=10m: mantiene el modelo cargado 10 minutos tras la última consulta. Usa -1 para mantenerlo siempre activo o 0 para descargarlo inmediatamente.
• OLLAMA_MAX_LOADED_MODELS=3: número máximo de modelos simultáneos en memoria (valor por defecto: 3).
• OLLAMA_NUM_PARALLEL=4: solicitudes paralelas máximas por modelo.

Ejemplo de Modelfile completo para uso general:

FROM qwen3:8b
PARAMETER temperature 0.4
PARAMETER min_p 0.05
PARAMETER num_ctx 16384
PARAMETER repeat_penalty 1.1
SYSTEM """
Eres un asistente técnico. Responde siempre en español de forma precisa y concisa.
Si no tienes certeza sobre algo, indícalo explícitamente.
"""

Para crear y usar el modelo personalizado:

ollama create mi-asistente -f Modelfile
ollama run mi-asistente

Para iniciar Ollama con variables de entorno en Linux/macOS:

OLLAMA_FLASH_ATTENTION=1 OLLAMA_KV_CACHE_TYPE=Q8_0 OLLAMA_KEEP_ALIVE=30m ollama serve

En Windows (PowerShell):

$env:OLLAMA_FLASH_ATTENTION="1"
$env:OLLAMA_KV_CACHE_TYPE="Q8_0"
$env:OLLAMA_KEEP_ALIVE="30m"
ollama serve

¿Cómo configurar LM Studio 0.4.6?

LM Studio 0.4.6 introduce varias mejoras relevantes: el componente llmster permite ejecutar modelos en servidores Linux o en entornos sin interfaz gráfica, y la función LM Link permite conectarse a instancias remotas de LM Studio como si fueran locales. En equipos ARM (Snapdragon X Elite), la versión ARM64 dedicada aprovecha las instrucciones nativas del procesador para mayor eficiencia.

Parámetros clave en la interfaz:

• Temperatura: 0.1–0.3 para análisis técnico o código; 0.4–0.6 para redacción; 0.7–0.9 para escritura creativa.
• Min-p: configurable en Advanced Settings; rango práctico: 0.03–0.1.
• Contexto: ajustable en Model Parameters; usa los valores de la tabla de tu perfil de hardware.
• Cuantización: se selecciona al descargar el modelo desde el catálogo integrado.
• Atención rápida: activa por defecto en CUDA desde v0.3.31; verificable en Performance Settings.
• Penalización de repetición: disponible en Advanced Settings; recomendado entre 1.1 y 1.2.

Para despliegue sin interfaz gráfica (llmster):

# En macOS o Linux:
curl -fsSL https://lmstudio.ai/install.sh | bash

# En Windows (PowerShell):
irm https://lmstudio.ai/install.ps1 | iex

SDK para integración con código:

# Python:
pip install lmstudio

# Node.js / JavaScript:
npm install @lmstudio/sdk

llama.cpp: referencia completa de parámetros

llama.cpp es el motor que ejecuta la inferencia en todas las herramientas anteriores, pero también puede usarse directamente desde la terminal para obtener control total. Desde mediados de 2025, el ejecutable principal cambió de nombre de ./main a ./llama-cli.

Parámetros de inferencia esenciales:

• –temp [valor]: temperatura de generación.
• –min-p [valor]: umbral mínimo de probabilidad relativa.
• –ctx-size [valor]: tamaño del contexto activo en unidades de texto.
• –flash-attn: activa la atención rápida.
• –n-gpu-layers [n]: número de capas del modelo procesadas en GPU. Usa -1 para enviar todas las capas posibles automáticamente.
• –repeat-penalty [valor]: penalización de repetición; 1.1–1.2 en la mayoría de los casos.
• –threads [n]: número de hilos de CPU para las capas no enviadas a GPU.
• –tensor-split [proporción]: para distribuir capas entre múltiples GPUs.
• –mirostat [0/1/2]: algoritmo de muestreo adaptativo; el valor 2 es el más estable para textos largos.

Backends disponibles y cuándo usarlos:

• CUDA: para GPU NVIDIA; máximo rendimiento; requiere controladores CUDA instalados.
• Metal: para GPU Apple Silicon; activo por defecto en macOS.
• ROCm/hipBLAS: para GPU AMD en Linux; rendimiento comparable a CUDA con drivers correctos.
• Vulkan: para GPU AMD, Intel Arc o cualquier GPU con soporte Vulkan en Windows/Linux; más sencillo de configurar que ROCm o SYCL, pero con menor rendimiento en algunos casos.
• SYCL: para GPU Intel Arc en Linux con oneAPI; ofrece mejor rendimiento que Vulkan en ese hardware.

Ejemplo para generación de código con GPU NVIDIA:

./llama-cli -m deepseek-coder-6.7b-Q5_K_M.gguf \
  --temp 0.1 \
  --min-p 0.0 \
  --ctx-size 16384 \
  --n-gpu-layers -1 \
  --flash-attn \
  --repeat-penalty 1.1 \
  --threads 4

Ejemplo con Vulkan para GPU AMD o Intel en Windows:

./llama-cli-vulkan -m mistral-7b-Q4_K_M.gguf \
  --temp 0.5 \
  --ctx-size 8192 \
  --n-gpu-layers 30 \
  --flash-attn \
  --threads 6

Configuraciones por caso de uso

Generación de código

Para código, la precisión es prioritaria sobre la diversidad. Desactivar min-p (valor 0.0) evita filtrar unidades de texto sintácticamente válidas con baja probabilidad relativa, y un contexto amplio mantiene la coherencia entre funciones de un mismo archivo.

Escritura creativa

La diversidad importa más que la precisión. Temperatura alta combinada con min-p bajo (0.03–0.05) permite resultados variados sin perder coherencia, y el parámetro mirostat 2 es especialmente útil para mantener la consistencia narrativa en textos extensos.

Análisis técnico y resúmenes de documentos

Temperatura baja y contexto amplio son la combinación esencial. Para documentos de más de 20 páginas, un contexto de 32768 o superior es necesario para no perder referencias entre secciones.

Solución de problemas comunes

¿Por qué el modelo repite frases o palabras?

• Aumenta la temperatura a 0.5–0.7.
• Establece la penalización de repetición entre 1.1 y 1.3.
• En llama.cpp, usa –repeat-penalty 1.2.
• En LM Studio, ajusta Repetition Penalty en Advanced Settings.

¿Cómo evitar que el modelo pierda el hilo de la conversación?

• Aumenta num_ctx a 16384 o 32768 según la memoria disponible.
• Activa la cuantización del caché de atención con OLLAMA_KV_CACHE_TYPE=Q8_0 en Ollama.
• En LM Studio, activa KV cache quantization en los ajustes del modelo.
• En llama.cpp, combina –ctx-size 32768 con –flash-attn.

El modelo responde con demasiada lentitud

• Verifica que la GPU esté siendo utilizada: en llama.cpp, la línea de inicio debe indicar el backend activo (CUDA, Metal, Vulkan, etc.).
• Activa la atención rápida: OLLAMA_FLASH_ATTENTION=1 o –flash-attn.
• Reduce la cuantización: Q4_K_M es más rápido que Q6_K con pérdida de calidad mínima.
• En llama.cpp, incrementa –n-gpu-layers progresivamente hasta que la GPU procese la mayor parte del modelo.
• En Snapdragon X Elite, asegúrate de usar la versión ARM64 nativa, no la versión x64 emulada.

¿Cómo reducir las respuestas inventadas?

• Reduce la temperatura a 0.1–0.3.
• Añade un mensaje de sistema explícito: “Responde solo con información verificable. Si no tienes certeza, indícalo claramente antes de responder.”
• Usa variantes del modelo con sufijo -instruct o -chat, que están ajustadas para seguir instrucciones con mayor fidelidad.
• Establece min-p=0.0 para dejar que la temperatura controle toda la diversidad sin filtros adicionales.

¿Qué hacer si el modelo no carga por falta de memoria?

• Reduce la cuantización al siguiente nivel inferior (de Q6_K a Q5_K_M, o de Q5 a Q4_K_M).
• En llama.cpp, reduce –n-gpu-layers para que parte del modelo se procese en CPU.
• En LM Studio, activa Auto-split layers para que el sistema distribuya automáticamente las capas entre GPU y RAM.
• Cierra otras aplicaciones que consuman memoria de video antes de cargar el modelo.
• Si la RAM del sistema es suficiente, el modelo puede ejecutarse parcialmente en CPU sin errores, aunque con menor velocidad.

Cómo interpretar las métricas de rendimiento

Tanto Ollama como llama.cpp reportan estadísticas de velocidad al finalizar cada respuesta. Saber interpretarlas ayuda a ajustar la configuración con criterio:

• prompt eval rate: velocidad a la que el modelo procesa el mensaje inicial (historial + pregunta). Valores bajos aquí indican que el contexto es muy largo para el hardware disponible.
• eval rate: velocidad durante la generación de la respuesta, medida en unidades de texto por segundo. Esta es la métrica más relevante para la experiencia del usuario.

Valores de referencia orientativos:

• Menos de 5 unidades/seg: velocidad baja; revisar capas en GPU o reducir cuantización.
• 5–15 unidades/seg: aceptable para uso ocasional o solo CPU.
• 15–40 unidades/seg: buena velocidad para uso cotidiano con GPU.
• Más de 40 unidades/seg: excelente; configuración bien optimizada.

Glosario de términos técnicos

• Logits: valores numéricos que representan la probabilidad sin procesar de cada unidad de texto posible, antes de aplicarse la función de normalización.
• Softmax: función matemática que convierte los logits en una distribución de probabilidades que suman 1.
• Caché KV: almacén de resultados de atención ya calculados para evitar recalcularlos en cada paso de generación, lo que reduce el consumo de memoria.
• Cuantización: técnica para reducir la precisión numérica de los pesos del modelo (de 16 bits a 4 o 5 bits) con el fin de ahorrar memoria y aumentar la velocidad.
• Atención rápida (Flash Attention): algoritmo que optimiza el cálculo de atención reduciendo las transferencias de datos entre la memoria de video y los núcleos de cómputo; especialmente útil en contextos largos.
• Perplejidad: métrica que mide qué tan bien un modelo predice secuencias de texto; valores más bajos indican mejor rendimiento predictivo.
• Unidad de texto (token): fragmento básico que el modelo procesa; puede ser una palabra, parte de una palabra o un símbolo especial.
• Contexto (num_ctx): número máximo de unidades de texto que el modelo considera activamente durante una sesión.
• Min-p: umbral dinámico que descarta unidades de texto con probabilidad inferior a un porcentaje del valor más alto en cada paso de generación.
• Mirostat: algoritmo de muestreo adaptativo que ajusta la diversidad de generación en tiempo real para mantener una perplejidad estable; útil en textos narrativos extensos.
• Penalización de presencia: reduce la probabilidad de cualquier unidad de texto que ya haya aparecido en el contexto, sin importar cuántas veces.
• Penalización de frecuencia: reduce la probabilidad de unidades de texto proporcionalmente a cuántas veces ya aparecieron; promueve variedad léxica.
• Backend: motor de cómputo que llama.cpp usa para ejecutar los cálculos; puede ser CUDA, Metal, ROCm, Vulkan o SYCL según el hardware disponible.
• NPU: unidad de procesamiento neuronal integrada en chips como Snapdragon X Elite; diseñada específicamente para operaciones de redes neuronales con alta eficiencia energética.
• MLX: motor de inferencia desarrollado por Apple, optimizado para chips de la serie M; ofrece mayor velocidad que llama.cpp en modelos medianos sobre Apple Silicon.

Recursos adicionales

• Repositorio oficial de llama.cpp: documentación de todos los parámetros, instrucciones de compilación por backend y discusiones técnicas.
• Documentación oficial de Ollama: referencia completa de variables de entorno, formato Modelfile y lista de modelos disponibles.
• Documentación de LM Studio 0.4.6: guías de instalación, ajustes de inferencia, SDK y novedades por versión.
• Descarga de LM Studio: versiones para Windows x64, Windows ARM64 (Snapdragon), macOS y Linux.
• Guía de cuantización en Hugging Face: referencia técnica sobre los distintos esquemas de cuantización y su impacto en calidad y rendimiento.
• Text Generation WebUI: interfaz alternativa con soporte para múltiples backends y ajustes avanzados de inferencia.