LM Studio: cómo instalar y correr modelos de IA local con interfaz gráfica (2026)

¿Qué es LM Studio?

LM Studio es una aplicación de escritorio gratuita, desarrollada por Element Labs, que permite descubrir, descargar y ejecutar modelos de lenguaje open source directamente en tu hardware — sin internet, sin nube, sin enviar datos a ningún servidor. Es, en pocas palabras, la forma más sencilla de correr IA local con una interfaz gráfica real.

Mientras que Ollama es un servidor con CLI, y llama.cpp es un motor de inferencia en C++, LM Studio es una GUI pulida primero, con un servidor OpenAI-compatible, una CLI (lms) y un daemon headless (llmster) por debajo.

📌 Lo esencial: LM Studio soporta modelos GGUF (llama.cpp, todas las plataformas) y MLX (Apple Silicon). Incluye chat con RAG, API server compatible con OpenAI, soporte MCP, y un daemon para servidores sin GUI. Gratis para uso personal.

¿Qué problema resuelve LM Studio?

Correr un LLM open source localmente solía significar: clonar llama.cpp, compilarlo con los flags BLAS correctos, buscar un quant GGUF en Hugging Face, y escribir un script de shell para arrancar un servidor. LM Studio colapsa todo eso en tres clics: instalas la app, buscas un modelo, clic en Download.

El problema más profundo es la inferencia offline por defecto. Nada en el chat de LM Studio envía datos a ningún servidor. Los modelos viven en tu disco, la inferencia ocurre en tu CPU o GPU, y el servidor API se绑定 a localhost a menos que lo expongas explícitamente. Para entornos regulados (legal, salud, finanzas), esto es a menudo la única configuración aceptable.

Requisitos del sistema

Plataforma	Requisitos	Aceleración GPU
macOS	macOS 14 (Sonoma)+ · Apple Silicon (M1/M2/M3/M4)	MLX (recomendado) o Metal via llama.cpp
Windows	Windows 10/11 · x64 o ARM64	CUDA (NVIDIA), Vulkan, DirectML
Linux	AppImage (la mayoría de distros)	CUDA (NVIDIA) o ROCm (AMD)

⚠️ Importante: Los Mac con Intel no son soportados a partir de LM Studio 0.3.x. Solo Apple Silicon (M1 en adelante). Para hardware más modesto, considera Ollama como alternativa más ligera.

RAM recomendada según tamaño de modelo

Tamaño de modelo	RAM mínima	RAM recomendada
3B-7B (Q4)	8 GB	16 GB
13B-14B (Q4)	16 GB	32 GB
33B-70B (Q4)	32 GB	64 GB
100B+ (Q4)	64 GB	128 GB+ o multi-GPU

Paso 1 — Descargar e instalar LM Studio

Descarga el instalador desde lmstudio.ai/download. La página detecta tu OS automáticamente.

macOS

Descarga el archivo .dmg
Abre el DMG y arrastra LM Studio a Applications
Primera ejecución: descarga automáticamente el runtime de llama.cpp + MLX para tu plataforma
No necesita Homebrew, Python ni Docker

Windows

Descarga el archivo .exe
Ejecuta el instalador con doble clic
El runtime se descarga automáticamente en el primer launch
Para GPU NVIDIA: asegúrate de tener los drivers CUDA actualizados

Linux

Descarga el archivo .AppImage
Dale permisos de ejecución: chmod +x LM_Studio-*.AppImage
Ejecuta: ./LM_Studio-*.AppImage
Para GPU: instala CUDA toolkit (NVIDIA) o ROCm (AMD) según tu GPU

Instalación headless (servidores sin GUI)

Si quieres correr LM Studio en un servidor sin interfaz gráfica, usa llmster, el daemon headless:

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

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

Esto instala el CLI lms y el daemon llmster sin necesidad de GUI.

Paso 2 — Descargar tu primer modelo

Abre LM Studio
Ve a la pestaña Discover en la barra lateral izquierda
Busca un modelo: "llama-3.3-8b", "qwen2.5-coder", "deepseek-coder", etc.
Verás todos los quants disponibles, con un badge verde (cabe en tu RAM/VRAM) o amarillo (spill a swap)
Clic en Download

Formatos soportados

Formato	Plataforma	Notas
GGUF	Todas (macOS, Windows, Linux)	Formato de llama.cpp. Quants: Q4_K_M, Q5_K_M, Q8_0
MLX	Solo Apple Silicon (M1-M4)	Framework nativo de Apple. 30-50% más rápido que llama.cpp/Metal

💡 Tip para Mac: Si tienes un Mac con Apple Silicon, prefiere MLX cuando esté disponible. Es 30-50% más rápido que llama.cpp/Metal en el mismo hardware, con menor uso de memoria. Si el modelo no tiene versión MLX, usa GGUF como fallback.

Modelos recomendados para empezar

Modelo	Tamaño	Ideal para
Llama 3.3 8B	~5 GB (Q4)	Chat general, versátil
Qwen2.5-Coder 14B	~9 GB (Q4)	Programación (mejor calidad en 32GB)
Qwen2.5-Coder 7B	~5 GB (Q4)	Programación en laptops
DeepSeek-Coder-V2-Lite	~10 GB (Q4)	Alternativa fuerte para código
Mistral 7B	~5 GB (Q4)	Rápido y eficiente
Phi-3.5 Mini	~2.5 GB (Q4)	Hardware modesto (8GB RAM)
Gemma 2 9B	~6 GB (Q4)	Chat de calidad, razonamiento

Paso 3 — Chatear con tu modelo

Ve a la pestaña Chat
Selecciona el modelo descargado en el dropdown superior
El modelo se carga en memoria (RAM/VRAM)
Escribe tu mensaje y presiona Enter

La interfaz de chat incluye:

Panel de system prompt a la derecha para configurar el comportamiento
Múltiples conversaciones simultáneas
Forkear desde cualquier mensaje
Regenerar y editar turnos anteriores
Sampling en vivo: temperature, top-p, top-k, repeat penalty
Contador de tokens/segundo en tiempo real

Paso 4 — Chat con documentos (RAG)

Una de las características más útiles de LM Studio es el chat con documentos completamente offline:

En la pestaña Chat, clic en el icono clip (paperclip)
Adjunta un archivo: PDF, TXT, DOCX, Markdown o código
LM Studio hace una de dos cosas automáticamente:
- Si cabe en el contexto: lo inlinea directamente
- Si es muy largo: lo trocea (chunking) y lo embebe para RAG
Pregúntale al modelo sobre el contenido del documento

El RAG usa nomic-ai/nomic-embed-text-v1.5-GGUF como modelo de embeddings por defecto y un sistema de recuperación estilo ChromaDB. Puedes cambiar el modelo de embeddings desde la pestaña Developer.

Paso 5 — Servidor API compatible con OpenAI

Esta es la función que convierte a LM Studio en una herramienta de desarrollo seria:

Ve a la pestaña Developer (antes "Local Server")
Carga un modelo en memoria
Clic en Start Server
Por defecto se binda a http://localhost:1234

Endpoints disponibles

POST /v1/chat/completions — Chat completions
POST /v1/completions — Text completions
POST /v1/embeddings — Embeddings
GET /v1/models — Listar modelos
POST /v1/chat — REST API stateful con soporte MCP (nuevo en 0.4.0)

Ejemplo en Python

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="lm-studio"
)

resp = client.chat.completions.create(
    model="llama-3.3-8b-instruct",
    messages=[{"role": "user", "content": "¿Qué es RAG?"}],
)

print(resp.choices[0].message.content)

Ejemplo en JavaScript/TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:1234/v1",
  apiKey: "lm-studio",
});

const resp = await client.chat.completions.create({
  model: "qwen2.5-coder-14b-instruct",
  messages: [{ role: "user", content: "Escribe una función quicksort en Python" }],
});

console.log(resp.choices[0].message.content);

Como las requests y responses son idénticas a la API de OpenAI, cualquier librería cliente de OpenAI funciona sin cambios. Solo cambia el base_url. Esto desbloquea todo el ecosistema: LangChain, LlamaIndex, Continue.dev, Cursor (modo local), Open WebUI y más.

Exponer en la red local

Por defecto, el servidor solo es accesible desde localhost. Para exponerlo en tu red local:

En la pestaña Developer, activa Serve on local network
El servidor se binda a 0.0.0.0
Combina con una regla de firewall para seguridad

Paso 6 — CLI: lms

LM Studio incluye una CLI lms instalada junto con la GUI. Después del primer launch, ejecuta lms bootstrap una vez para registrar el binario en tu PATH.

Comandos esenciales

# === Gestión de modelos ===
lms get llama-3.3-8b-instruct    # Descargar modelo
lms ls                            # Listar modelos instalados
lms load llama-3.3-8b-instruct    # Cargar en memoria
lms unload --all                  # Descargar todos

# === Servidor ===
lms server start --port 1234      # Iniciar servidor API
lms server status                 # Ver estado del servidor
lms server stop                   # Detener servidor

# === Daemon headless ===
lms daemon up                     # Iniciar daemon (sin GUI)
lms daemon down                   # Detener daemon

# === Chat interactivo ===
lms chat llama-3.3-8b-instruct    # REPL interactivo

# === Logs ===
lms log stream                    # Stream de logs en vivo

Paso 7 — Soporte MCP y workflows agénticos

A partir de LM Studio 0.3.x, la app incluye soporte first-class para MCP (Model Context Protocol). La pestaña Developer tiene un panel de MCP Servers donde puedes pegar la config de cualquier servidor MCP y el modelo cargado verá esas herramientas en su contexto.

Casos prácticos

Filesystem MCP: conecta un servidor de archivos y pídele a un modelo Qwen2.5-Coder que lea y edite archivos en disco
SQLite MCP: ejecuta queries analíticos contra una base de datos local mediante lenguaje natural
Web Search MCP: investigación offline-first que busca en la web cuando es necesario
MCPs personalizados: crea tus propios servidores MCP para cualquier integración

La calidad del tool-use depende del modelo, no de LM Studio. Modelos como Qwen2.5, Llama 3.3 y DeepSeek-Coder-V2 manejan function calling competentemente; los modelos pequeños de 3B pueden tener dificultades.

Paso 8 — Code completion con LM Studio

LM Studio es cada vez más viable como backend para completado de código local:

Continue.dev (VS Code / JetBrains)

Edita ~/.continue/config.json:

{
  "models": [{
    "provider": "openai",
    "apiBase": "http://localhost:1234/v1",
    "model": "qwen2.5-coder-14b-instruct",
    "apiKey": "lm-studio"
  }]
}

Cursor

En Settings, override el OpenAI base URL a http://localhost:1234/v1. Cursor enrutará el chat a través de tu modelo local. El Tab completion sigue necesitando el modelo remoto pequeño de Cursor a menos que lo desactives.

⚠️ Nota realista: Los modelos de código locales siguen estando por detrás de Claude Sonnet, GPT-5.5 o GLM-5.2 en refactors difíciles y razonamiento multi-archivo. Usa LM Studio para trabajo offline, codebases sensibles o completados simples; recurre a un modelo frontier cuando la tarea sea compleja.

LM Studio 0.4.0: novedades 2026

llmster: el core de LM Studio empaquetado como daemon para servidores sin GUI. Instalable vía script, corre como servicio systemd
Requests paralelos con continuous batching: en lugar de encolar requests uno a uno, el modelo procesa hasta N requests simultáneamente (default: 4 slots paralelos)
Nueva REST API stateful (/v1/chat): inicia una conversación, recibe un response_id, y continúa pasando previous_response_id. Soporta MCPs locales con permission keys
UI renovada: chat export, split view, developer mode, docs in-app
llama.cpp engine 2.0.0: soporte para inferencia concurrente al mismo modelo

LM Studio vs Ollama vs llama.cpp

Característica	LM Studio	Ollama	llama.cpp
Interfaz	GUI completa ✅	CLI	CLI / lib
MLX (Apple Silicon)	Sí ✅ (30-50% más rápido)	No (Metal via llama.cpp)	No (Metal backend)
API OpenAI-compatible	Sí (localhost:1234)	Sí (localhost:11434)	Sí (server mode)
Browser de modelos	Integrado (Hugging Face) ✅	Comando pull	Manual
RAG (chat con docs)	Integrado ✅	No nativo	No nativo
MCP support	Sí ✅	Vía herramientas externas	No
Headless / daemon	llmster ✅	Docker-native ✅	Sí
Requests paralelos	Sí (continuous batching) ✅	Sí	Sí (con flags)
Ideal para	GUI + MLX + RAG + MCP	Terminal + Docker	Máximo control y rendimiento

💡 Cuándo elegir cada uno: Usa LM Studio cuando quieras una GUI real, MLX en Mac, RAG integrado y MCP. Usa Ollama cuando vivas en la terminal y quieras deploys Docker-native. Usa llama.cpp cuando necesites cada último token/segundo y te sientas cómodo con build flags de C++.

Integración con otras herramientas del ecosistema IA

LM Studio no vive aislado. Su API OpenAI-compatible lo convierte en el backend perfecto para otras herramientas de IA que ya cubrimos en Blogia:

Hermes Agent

Hermes Agent soporta Ollama como proveedor de modelos locales, y mediante la API OpenAI-compatible de LM Studio puedes configurarlo como backend alternativo. Solo apunta la base_url de Hermes a http://localhost:1234/v1 y usa lm-studio como API key.

OpenClaw

OpenClaw puede usar LM Studio como proveedor de modelos en tu VPS o localmente. Si corres llmster como daemon en un servidor, OpenClaw puede consumirlo como cualquier endpoint OpenAI-compatible. Ideal para mantener tu asistente IA con modelos 100% privados.

Supabase self-hosted + LM Studio

Si ya tienes Supabase self-hosted en tu VPS, puedes combinarlo con LM Studio (o llmster headless) para construir aplicaciones con IA 100% privada: Supabase maneja la base de datos y auth, LM Studio sirve los modelos de IA, todo en tu propia infraestructura.

GLM-5.2 y modelos frontier

Para tareas que requieren la máxima capacidad, GLM-5.2 es la alternativa open source más cercana a Claude Opus. Sin embargo, GLM-5.2 requiere hardware significativo (744B parámetros). LM Studio es ideal para modelos más pequeños que corren en hardware cotidiano, mientras que GLM-5.2 es para cuando necesitas capacidad frontier y tienes el hardware para soportarlo.

Solución de problemas

Out of memory (OOM) en modelos grandes

Revisa el badge verde/amarillo en el browser de modelos. Un badge amarillo significa que el quant spillará a swap, lo que mata el rendimiento. Usa un quant más pequeño (Q4_K_M en lugar de Q8_0) o un modelo más pequeño.

Primer token lento después de idle

LM Studio descarga modelos de VRAM después de un timeout de idle. Ajusta Keep model in memory en la pestaña Developer para mantener el modelo cargado.

"My new model won't load"

La causa más común es un runtime desactualizado. LM Studio actualiza los engines (llama.cpp, MLX) independientemente de la app. Ve a Settings → Runtime y actualiza el engine.

Modelo MLX no disponible para un modelo nuevo

Las arquitecturas brand-new suelen llegar a GGUF primero. El lag para que la comunidad porte a MLX suele ser de días a semanas. Usa GGUF como fallback mientras tanto.

Servidor solo accesible desde localhost

Es por diseño. Activa Serve on local network en la pestaña Developer para bindar a 0.0.0.0. Combina con una regla de firewall.

Error de CRLF en Windows

Si algunos modelos no cargan en Windows, verifica que los archivos no tengan line endings CRLF. LM Studio maneja esto automáticamente en instalaciones nuevas, pero puede ocurrir si copiaste configs manualmente.

Cuándo NO usar LM Studio

Producción a escala: Usa vLLM o TGI. LM Studio es single-process, single-node

Servidor Linux headless puro: `llmster` funciona, pero el diseño Docker-first de Ollama es más amigable

Control fino de build flags de llama.cpp: Usa llama.cpp directamente

Multi-tenant: LM Studio es single-user, no hay auth en la API local

Conclusión

LM Studio es la forma más sencilla de empezar con IA local. Si quieres chatear con Llama, Qwen o DeepSeek en tu máquina sin tocar la terminal, descargar un modelo con un clic, o tener un endpoint OpenAI-compatible para prototipar, no hay nada más rápido.

Su mayor fortaleza es la fricción cero: no necesitas Docker, Python, Homebrew ni compilar nada. Descargas la app, buscas un modelo, clic, y estás chateando con IA offline en minutos. Y cuando necesitas más — API server, RAG, MCP, headless daemon — todo está ahí, una pestaña away.

Para construir un stack de IA local completo, combina LM Studio con las otras herramientas que cubrimos en Blogia: Ollama para el servidor de modelos, Hermes Agent para orquestación, OpenClaw para tu asistente IA, Supabase self-hosted para el backend, y GLM-5.2 cuando necesites capacidad frontier. Todo open source, todo en tu control.

🔗 Enlaces de interés:

📚 Posts relacionados en Blogia: