LM Studio + Hugging Face: guía práctica para ejecutar LLMs en local

0. Resumen en 60 segundos

Instala LM Studio (macOS, Windows o Linux).
Crea una cuenta en Hugging Face y un token de lectura.
Busca un modelo en formato GGUF, preferiblemente cuantización Q4_K_M.
Descárgalo desde el buscador integrado de LM Studio, desde la web de Hugging Face o con la CLI hf.
Carga el modelo, ajusta context length, GPU offload y plantilla de chat.
Usa el chat o activa el servidor local compatible con OpenAI en http://localhost:1234/v1.
Para RAG, añade un modelo de embeddings y una base vectorial.
Para automatizar, usa la CLI lms y el servidor headless.

1. Las piezas del ecosistema

Antes de tocar nada conviene entender qué hace cada componente:

Pieza	Qué es	Papel
Hugging Face	Hub de modelos, datasets y demos	Repositorio donde viven los pesos
GGUF	Formato de pesos cuantizados para `llama.cpp`	El formato que consume LM Studio
LM Studio	Aplicación de escritorio + runtime + servidor	Interfaz, carga del modelo, API local
Cuantización	Compresión con pérdida de los pesos	Permite ejecutar modelos grandes en hardware modesto
llama.cpp	Motor de inferencia en C/C++	Base técnica de LM Studio para GGUF
Embeddings	Representaciones vectoriales de texto	Necesarios para RAG, búsqueda semántica y clustering

LM Studio no entrena modelos: ejecuta inferencia. Si quieres fine-tuning, necesitarás herramientas como Unsloth, Axolotl, PEFT o llama.cpp para convertir y quantizar.

2. Requisitos de hardware

No hay una regla universal, pero esta tabla orienta bastante bien para modelos densos en Q4_K_M:

Memoria disponible	Modelos razonables	Experiencia
8 GB RAM	1B–3B `Q4`	Justo; contextos cortos
16 GB RAM	7B–8B `Q4`	Uso general fluido en CPU/GPU moderada
24 GB RAM/VRAM	13B–14B `Q4`, 8B `Q8`	Buena calidad
32 GB RAM/VRAM	30B `Q4`, 14B `Q6`	Muy buena, algo más lento
64 GB RAM/VRAM	70B `Q4`, 30B `Q6/Q8`	Posible, pero exigente
128 GB+	70B `Q6/Q8`, modelos MoE grandes	Nivel estación de trabajo

Regla rápida de memoria

Q4_K_M ≈ 0,5–0,6 GB por cada 1B de parámetros.
Q8_0 ≈ 1 GB por cada 1B.
F16 ≈ 2 GB por cada 1B.
Añade 20–40 % extra para caché KV, contexto, overhead del runtime y sistema operativo.

Ejemplos:

7B en Q4_K_M ≈ 4–5 GB.
8B en Q4_K_M ≈ 5 GB.
14B en Q4_K_M ≈ 8–9 GB.
32B en Q4_K_M ≈ 19–21 GB.
70B en Q4_K_M ≈ 42–45 GB.

Apple Silicon, NVIDIA y CPU

Apple Silicon: memoria unificada; la GPU puede usar buena parte de la RAM. Empieza con GPU Offload = Max y baja si hay presión de memoria.
NVIDIA: instala drivers actualizados. LM Studio aprovecha CUDA cuando está disponible.
AMD/Intel: funcionará por Vulkan/ROCm según plataforma y versión; el rendimiento varía.
CPU sola: útil para modelos pequeños o para probar; la velocidad será mucho menor.

3. Instalación de LM Studio

macOS

Descarga el .dmg desde lmstudio.ai.
Arrastra la app a /Applications.
Si Gatekeeper lo bloquea, abre con clic derecho → Abrir.
En el primer arranque, elige la carpeta de modelos. Por defecto: ~/.lmstudio/models.

Windows

Descarga el instalador desde la web oficial.
Instala y abre.
Verifica que detecta tu GPU en Settings → Hardware.
Carpeta por defecto: %USERPROFILE%\.lmstudio\models.

Linux

Descarga el AppImage.
Dale permisos: chmod +x LM-Studio-*.AppImage.
Ejecútalo. Si FUSE no está disponible, usa --appimage-extract-and-run.
La CLI suele quedar en ~/.lmstudio/bin/lms.

Primer arranque

Revisa Settings → General: carpeta de modelos, idioma, telemetría.
Revisa Settings → Hardware: GPU detectada, VRAM, hilos de CPU.
Instala la CLI si quieres automatizar: en la app suele haber una opción tipo Install CLI o Enable CLI.
Comprueba en terminal:

lms --help

Si no aparece, añade al PATH:

export PATH="$HOME/.lmstudio/bin:$PATH"

4. Preparar Hugging Face

Cuenta y token

Crea una cuenta en huggingface.co.
Ve a Settings → Access Tokens.
Crea un token con permiso de lectura (read).
Guárdalo en un gestor de secretos, no en el repositorio.

Modelos con acceso restringido

Algunos modelos (por ejemplo, ciertas versiones de Llama o Gemma) requieren aceptar una licencia en la model card. Si no lo haces, la descarga devolverá 401 o 403.

Buscar modelos GGUF

En Hugging Face:

Filtra por GGUF.
Ordena por Trending o Most downloads.
Revisa que exista una carpeta con ficheros .gguf.
Lee la model card: licencia, contexto máximo, idiomas, plantilla de chat y requisitos.

Búsqueda típica:

https://huggingface.co/models?search=gguf

Repositorios interesantes:

lmstudio-community: conversiones GGUF mantenidas por la comunidad de LM Studio.
bartowski: gran catálogo de cuantizaciones.
TheBloke: histórico, aunque menos actualizado en algunos modelos.
Repos oficiales de Qwen, Mistral, Meta, Google, Microsoft, DeepSeek.

5. Cuatro formas de llevar un modelo de Hugging Face a LM Studio

5.1 Buscador integrado de LM Studio

Es la ruta más sencilla:

Abre la pestaña Search o Discover.
Busca el modelo, por ejemplo Qwen2.5 7B Instruct.
Filtra por GGUF si hace falta.
Elige la cuantización Q4_K_M.
Pulsa Download.
Cuando termine, ve a Chat o My Models y cárgalo.

Ventajas: gestiona carpetas, dependencias y actualizaciones. Desventaja: el catálogo integrado no contiene todos los modelos de Hugging Face.

5.2 Descarga manual desde la web de Hugging Face

Abre la pestaña Files and versions del repositorio.
Descarga el .gguf deseado.
Colócalo en una carpeta dentro de tu directorio de modelos:

~/.lmstudio/models/
  lmstudio-community/
    Qwen2.5-7B-Instruct-GGUF/
      Qwen2.5-7B-Instruct-Q4_K_M.gguf

En LM Studio, pulsa Refresh en My Models.
Si no aparece, usa Import Model y selecciona el fichero o la carpeta.

En Windows:

%USERPROFILE%\.lmstudio\models\lmstudio-community\Qwen2.5-7B-Instruct-GGUF\

Consejo: mantén la estructura editor/repositorio/fichero.gguf. Evita nombres con espacios raros y verifica el tamaño y el hash si el repo lo publica.

5.3 CLI de Hugging Face

Instala la CLI:

python3 -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install -U "huggingface_hub[cli]"

Autentícate:

hf auth login

O usa variable de entorno:

export HF_TOKEN="***"

Descarga solo el fichero que te interesa:

hf download lmstudio-community/Qwen2.5-7B-Instruct-GGUF \
  --include "*Q4_K_M.gguf" \
  --local-dir ~/.lmstudio/models/lmstudio-community/Qwen2.5-7B-Instruct-GGUF

Para un modelo con visión necesitarás también el proyector multimodal (mmproj):

hf download <repo> --include "*Q4_K_M.gguf" --include "*mmproj*.gguf" --local-dir ./modelo

Ventajas: reproducible, scriptable, permite fijar revisión:

hf download <repo> --revision <commit_sha> --include "*.gguf" --local-dir ./modelo

5.4 CLI de LM Studio

La CLI lms permite buscar, descargar, cargar y servir modelos:

lms --help
lms ls
lms get qwen2.5

lms get abre un buscador o descarga desde el catálogo según la versión. Para cargar:

lms load <identificador-del-modelo> --gpu max --context-length 8192

Para arrancar el servidor:

lms server start --port 1234

Para ver qué está cargado:

lms ps

Para descargar de memoria:

lms unload --all

Consejo: usa lms ls para obtener el identificador exacto que LM Studio asigna al modelo.

6. Elegir modelo y cuantización

6.1 Instruct vs. base

Base: solo predice el siguiente token. Útil para fine-tuning o experimentos.
Instruct / Chat: ajustado para seguir instrucciones y conversar. Es lo que quieres para el 95 % de casos.
Reasoning: modelos que generan cadenas de razonamiento antes de responder (por ejemplo, destilados de DeepSeek-R1). Útiles para matemáticas y lógica, pero más lentos y verbosos.

6.2 Tabla de cuantizaciones

Cuantización	Bits aprox.	Calidad	Tamaño 7B	Recomendación
`Q2_K`	~2,5	Baja	~2,8 GB	Último recurso
`Q3_K_M`	~3,5	Aceptable	~3,5 GB	Hardware muy limitado
`Q4_0`	4	Buena	~3,8 GB	Compatibilidad
`Q4_K_M`	~4,5	Muy buena	~4,4 GB	Punto de partida
`Q5_K_M`	~5,5	Excelente	~5,1 GB	Si sobra memoria
`Q6_K`	~6,5	Casi sin pérdida	~5,9 GB	Calidad alta
`Q8_0`	~8,5	Prácticamente idéntica a F16	~7,5 GB	Si hay RAM/VRAM
`F16`	16	Referencia	~14 GB	Conversión, no uso diario

Para uso general: Q4_K_M. Para código, extracción de datos o tareas sensibles: Q5_K_M o Q6_K. Para modelos pequeños (1B–3B), considera Q8_0 porque el ahorro de Q4 no compensa tanto.

6.3 Modelos recomendados para empezar

Modelo	Tamaño	Licencia	Punto fuerte
Qwen2.5-7B-Instruct	7B	Apache 2.0	Multilingüe, español decente, generalista
Llama-3.1-8B-Instruct	8B	Llama 3.1	Generalista, herramientas, ecosistema enorme
Mistral-7B-Instruct-v0.3	7B	Apache 2.0	Rápido, ligero, buena base
Gemma-2-9B-it	9B	Gemma Terms	Buena calidad conversacional
Phi-3.5-mini-instruct	3,8B	MIT	Muy pequeño y capaz para su tamaño
DeepSeek-R1-Distill-Qwen-7B	7B	MIT	Razonamiento
Qwen2.5-Coder-7B-Instruct	7B	Apache 2.0	Código
nomic-embed-text-v1.5	137M	Apache 2.0	Embeddings
bge-m3	568M	MIT	Embeddings multilingües
Qwen2-VL-7B-Instruct	7B	Apache 2.0	Visión (requiere `mmproj`)

Comprueba siempre la licencia en la model card: no es lo mismo Apache 2.0 que una licencia con cláusulas de uso comercial o límites de usuarios.

7. Cargar y configurar el modelo

7.1 Context length

Es el número máximo de tokens que el modelo puede “ver” a la vez (prompt + respuesta + historial). Más contexto:

Consume más memoria (especialmente caché KV).
Puede ralentizar la generación.
No siempre mejora la calidad; a veces diluye la atención.

Recomendación:

Chat general: 4k–8k.
Documentos largos: 16k–32k.
No pongas 128k “porque el modelo lo soporta” si no lo necesitas.

7.2 GPU offload

Número de capas que se envían a la GPU. En LM Studio suele haber un control de capas o un botón Max.

Estrategia:

Prueba Max.
Si hay error de memoria, baja capas progresivamente.
Si va lento, comprueba que realmente está usando GPU y no CPU.
En Apple Silicon, vigila la presión de memoria del sistema.

7.3 Opciones avanzadas

Flash Attention: actívalo si tu hardware y la versión lo soportan; suele reducir memoria y mejorar velocidad.
K/V cache quantization: Q8_0 suele ser seguro; Q4_0 ahorra más pero puede degradar.
Batch size: más batch acelera el prompt processing, pero consume memoria.
Keep model in memory: útil si vas a hacer muchas peticiones; innecesario en un portátil con poca RAM.
mmap: deja que el sistema gestione el fichero; útil si no cabe entero en RAM, aunque puede ir más lento.

7.4 Plantilla de chat

Cada modelo espera un formato concreto (ChatML, Llama 3, Mistral, Gemma…). LM Studio normalmente lo detecta desde los metadatos GGUF. Si el modelo responde mal, con roles raros o repite el prompt:

Revisa la model card.
Selecciona manualmente la plantilla correcta.
Prueba una pregunta simple antes de construir un flujo encima.

7.5 Parámetros de muestreo

Uso	Temperature	Top-p	Repeat penalty
Chat general	0,7	0,9	1,1
Código	0,1–0,3	0,95	1,05
Creatividad	0,9–1,1	0,95	1,1
Extracción/JSON	0,0–0,2	1,0	1,0
RAG factual	0,1–0,3	0,9	1,05

Temperature controla la aleatoriedad; top-p recorta la cola de probabilidad; repeat penalty evita bucles. No cambies cinco parámetros a la vez: prueba uno y evalúa.

7.6 System prompt

Ejemplo para un asistente técnico en español:

Eres un asistente técnico especializado en análisis de datos y Python.
Responde en español, con ejemplos concretos y código ejecutable.
Si no sabes algo, dilo y propone cómo verificarlo.
No inventes APIs ni rutas de archivos.

7.7 Structured output

LM Studio permite definir un esquema JSON para forzar la salida. Ejemplo conceptual:

{
  "type": "object",
  "properties": {
    "sentimiento": {
      "type": "string",
      "enum": ["positivo", "neutral", "negativo"]
    },
    "confianza": {
      "type": "number",
      "minimum": 0,
      "maximum": 1
    }
  },
  "required": ["sentimiento", "confianza"]
}

Esto es muy útil para clasificación, extracción de entidades y pipelines de datos. Aun así, valida siempre la salida con Pydantic o JSON Schema.

7.8 Tool use / function calling

Algunos modelos soportan herramientas. La calidad varía mucho: Llama 3.1, Qwen2.5 y Mistral suelen defenderse bien. Si el modelo no soporta tool calling nativo, puedes simularlo pidiendo JSON y ejecutando tú la función.

8. Usar el chat de LM Studio

Funciones útiles:

Comparar modelos en paralelo para una misma pregunta.
Presets con system prompt y parámetros guardados.
Chat with documents para probar RAG sin escribir código.
Adjuntar imágenes si el modelo es multimodal.
Historial y carpetas para organizar conversaciones.

Buenas prácticas de prompting:

Da contexto y objetivo antes de la pregunta.
Especifica formato de salida.
Incluye ejemplos si la tarea es ambigua.
Divide tareas complejas en pasos.
Para RAG, pide al modelo que cite el fragmento usado.
No confíes en el modelo para cálculos críticos sin verificación.

9. Servidor local compatible con OpenAI

LM Studio puede exponer una API HTTP que imita la de OpenAI. Esto permite conectar cualquier herramienta que acepte un base_url personalizado.

9.1 Arrancar el servidor

Desde la interfaz:

Ve a Developer o Local Server.
Selecciona el modelo cargado.
Activa Start Server.
Puerto por defecto: 1234.
Si quieres acceso desde la red local, activa la opción correspondiente y revisa el firewall.

Desde CLI:

lms server start --port 1234

Endpoint base:

http://localhost:1234/v1

9.2 Endpoints habituales

GET /v1/models
POST /v1/chat/completions
POST /v1/completions
POST /v1/embeddings

9.3 curl

curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-7b-instruct",
    "messages": [
      {"role": "system", "content": "Responde en español y con ejemplos."},
      {"role": "user", "content": "Explica qué es la cuantización GGUF en 5 líneas."}
    ],
    "temperature": 0.7,
    "max_tokens": 300
  }'

9.4 Python con el SDK de OpenAI

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="***",  # cualquier string si no has activado auth
)

respuesta = client.chat.completions.create(
    model="qwen2.5-7b-instruct",
    messages=[
        {"role": "system", "content": "Eres un analista de datos riguroso."},
        {"role": "user", "content": "Dame 3 comprobaciones antes de unir dos tablas."},
    ],
    temperature=0.3,
)

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

Streaming:

stream = client.chat.completions.create(
    model="qwen2.5-7b-instruct",
    messages=[{"role": "user", "content": "Escribe un haiku sobre datos."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

9.5 JavaScript / TypeScript

import OpenAI from "openai";

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

const res = await client.chat.completions.create({
  model: "qwen2.5-7b-instruct",
  messages: [{ role: "user", content: "Resume este texto en 3 bullets." }],
});

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

9.6 LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="http://localhost:1234/v1",
    api_key="***",
    model="qwen2.5-7b-instruct",
    temperature=0.2,
)

print(llm.invoke("¿Qué es un embedding?").content)

9.7 n8n

Dos opciones:

OpenAI node: crea una credencial de OpenAI y cambia el Base URL a http://localhost:1234/v1. La API key puede ser cualquier texto.
HTTP Request node: llama directamente a POST http://localhost:1234/v1/chat/completions con el JSON del ejemplo.

Si n8n corre en Docker, localhost dentro del contenedor no es tu Mac. Usa http://host.docker.internal:1234/v1 o la IP de tu máquina en la red local.

9.8 Embeddings

resp = client.embeddings.create(
    model="text-embedding-nomic-embed-text-v1.5",
    input=["primera frase", "segunda frase"],
)

vector = resp.data[0].embedding
print(len(vector))

Usa el identificador exacto que aparezca en LM Studio para el modelo de embeddings.

9.9 Seguridad del servidor

Por defecto, escucha en localhost. No lo expongas a Internet sin protección.
Si activas acceso en red, usa firewall y, idealmente, un reverse proxy con autenticación.
No subas conversaciones con datos personales a modelos remotos si puedes resolverlo en local.
Revisa los logs y limita el tamaño de las peticiones.

10. RAG local paso a paso

RAG (Retrieval-Augmented Generation) combina búsqueda semántica con generación. En local es totalmente viable y es uno de los usos más potentes de LM Studio.

Arquitectura

Documentos → extracción de texto → chunks → embeddings → base vectorial
                                                              ↓
Pregunta → embedding → búsqueda top-k → contexto → LLM → respuesta

Paso 1: modelo de embeddings

Carga en LM Studio un modelo como nomic-embed-text-v1.5 o bge-m3. Arranca el servidor y comprueba que /v1/embeddings responde.

Paso 2: extracción de texto

Para PDFs:

pip install pypdf

from pypdf import PdfReader

reader = PdfReader("documento.pdf")
texto = "\n".join(page.extract_text() or "" for page in reader.pages)

Para HTML, Markdown o DOCX, usa unstructured, beautifulsoup4, python-docx o markitdown.

Paso 3: chunking

Reglas prácticas:

500–1.000 tokens por chunk.
10–20 % de solapamiento.
Respeta párrafos y secciones.
Guarda metadatos: fuente, página, título, fecha.

def chunks(texto, tamaño=800, solape=120):
    palabras = texto.split()
    paso = tamaño - solape
    for i in range(0, len(palabras), paso):
        yield " ".join(palabras[i:i + tamaño])

Para producción, usa un tokenizador real y no partas tablas o código por la mitad.

Paso 4: base vectorial

Opciones: Chroma, FAISS, LanceDB, Qdrant, pgvector. Para empezar, Chroma es muy cómodo:

pip install chromadb

import chromadb
from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="***")
chroma = chromadb.PersistentClient(path="./chroma_db")
coleccion = chroma.get_or_create_collection("documentos")

fragmentos = list(chunks(texto))
resp = client.embeddings.create(
    model="text-embedding-nomic-embed-text-v1.5",
    input=fragmentos,
)
vectores = [d.embedding for d in resp.data]

coleccion.add(
    documents=fragmentos,
    embeddings=vectores,
    ids=[f"doc-{i}" for i in range(len(fragmentos))],
    metadatas=[{"fuente": "documento.pdf"} for _ in fragmentos],
)

Paso 5: consulta

pregunta = "¿Qué requisitos de hardware recomienda la guía?"
q = client.embeddings.create(
    model="text-embedding-nomic-embed-text-v1.5",
    input=[pregunta],
).data[0].embedding

resultados = coleccion.query(query_embeddings=[q], n_results=4)
contexto = "\n\n---\n\n".join(resultados["documents"][0])

prompt = f"""Responde usando solo el contexto. Si no está, di que no lo sabes.
Cita la fuente entre corchetes.

Contexto:
{contexto}

Pregunta: {pregunta}
"""

resp = client.chat.completions.create(
    model="qwen2.5-7b-instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,
)
print(resp.choices[0].message.content)

Buenas prácticas RAG

Evalúa la recuperación por separado de la generación.
Guarda el chunk_id y la fuente para poder auditar.
Prueba distintos top-k (3, 5, 8).
Añade reranking si la calidad es crítica.
No metas 20 documentos en el prompt: diluye la atención.
Para documentación técnica, conserva títulos y rutas.

11. Automatización y modo headless

Comandos útiles

lms ls
lms ps
lms load <modelo> --gpu max --context-length 8192
lms server start --port 1234
lms unload --all

Script de arranque

#!/usr/bin/env bash
set -euo pipefail

MODELO="${1:-qwen2.5-7b-instruct}"

lms server start --port 1234
lms load "$MODELO" --gpu max --context-length 8192

echo "Servidor listo en http://localhost:1234/v1"

Health check

curl -s http://localhost:1234/v1/models | jq .

Programar el arranque

macOS: launchd con un .plist.
Linux: systemd service.
Windows: Programador de tareas.
Docker/CI: no es el entorno natural de LM Studio; para servidores multiusuario considera vLLM, TGI o llama.cpp server.

Integración con n8n

Flujo típico:

Trigger (webhook, cron, email).
HTTP Request a LM Studio.
Parseo de JSON.
Validación con un nodo Code.
Acción: guardar en base de datos, enviar email, publicar en WordPress.

Consejo: añade timeouts y reintentos. Un modelo local puede tardar más que una API en frío, sobre todo la primera petición.

12. Convertir y quantizar modelos de Hugging Face

LM Studio consume GGUF. Si el modelo solo está en formato transformers (safetensors), tienes que convertirlo con llama.cpp.

Requisitos

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Convertir a GGUF F16

python convert_hf_to_gguf.py ./mi-modelo \
  --outfile mi-modelo-f16.gguf \
  --outtype f16

Quantizar

./llama-quantize mi-modelo-f16.gguf mi-modelo-Q4_K_M.gguf Q4_K_M

Subir a Hugging Face

hf upload <usuario>/<repositorio> mi-modelo-Q4_K_M.gguf

Añade una model card con:

Modelo base y licencia.
Comandos de conversión y quantización.
Tamaño y requisitos.
Limitaciones conocidas.
Ejemplo de uso con LM Studio.

No todos las arquitecturas están soportadas el mismo día. Revisa issues de llama.cpp y prueba una generación corta antes de publicar.

13. Problemas comunes y soluciones

Síntoma	Causa probable	Solución
`401` o `403` al descargar	Modelo con acceso restringido	Acepta la licencia y configura `HF_TOKEN`
El modelo no aparece	Carpeta incorrecta o formato no GGUF	Revisa ruta, refresca, importa manualmente
`out of memory`	Contexto o capas GPU demasiado altas	Baja contexto, cuantización o capas
Generación lentísima	Modelo en CPU, poca VRAM, contexto enorme	Aumenta offload, usa `Q4_K_M`, reduce contexto
Texto incoherente	Cuantización muy baja, plantilla incorrecta, descarga corrupta	Prueba `Q5_K_M`, revisa chat template, redescarga
Repite el prompt	Plantilla de chat incorrecta	Selecciona la plantilla de la model card
Error de contexto	Prompt + historial superan el límite	Aumenta contexto o recorta historial
El servidor no responde	No está iniciado, puerto ocupado, firewall	`lms server start`, cambia puerto, revisa red
Se cae en macOS	Presión de memoria, Metal, versión antigua	Actualiza, reduce contexto, cierra apps
Respuestas en inglés	System prompt débil o modelo pequeño	Refuerza idioma, prueba Qwen/Llama
JSON inválido	Modelo pequeño o esquema complejo	Baja temperatura, usa structured output, valida
Embeddings fallan	Modelo de chat en vez de embeddings	Carga un modelo dedicado a embeddings

Diagnóstico rápido

Prueba el modelo en el chat de LM Studio.
Si falla ahí, el problema es del modelo o del hardware.
Si funciona ahí pero no en la API, revisa endpoint, modelo y JSON.
Si funciona en local pero no en Docker/n8n, revisa red y host.docker.internal.
Mira los logs de LM Studio antes de tocar parámetros al azar.

14. Seguridad, privacidad y licencias

Privacidad

Todo el procesamiento ocurre en tu máquina.
Una vez descargado el modelo, no necesitas Internet.
Cuidado con plugins, telemetría y herramientas que envíen datos fuera.
Si procesas datos personales, documenta el flujo y limita el acceso al servidor local.

Licencias

Antes de usar un modelo en un producto:

Lee la licencia en la model card.
Comprueba si permite uso comercial.
Revisa límites de usuarios, atribución o restricciones sectoriales.
Guarda una copia de la licencia y de la revisión usada.
No asumas que “está en Hugging Face” significa “es libre para todo”.

Buenas prácticas

Fija versiones y revisa actualizaciones.
Evalúa con un conjunto propio de preguntas.
No uses el modelo como única fuente de verdad.
Revisa sesgos y alucinaciones en dominios sensibles.
Mide latencia, tokens/segundo y memoria antes de escalar.
Guarda presets y prompts en control de versiones.

15. Comparativa de alternativas

Herramienta	Facilidad	API OpenAI	Rendimiento	Multiusuario	Ideal para
LM Studio	Muy alta	Sí	Bueno en local	Limitado	Escritorio, prototipos, aprendizaje
Ollama	Alta	Sí	Bueno	Medio	CLI, scripts, Docker
llama.cpp	Media	Sí (server)	Muy bueno	Medio	Control fino, embebidos
vLLM	Media-baja	Sí	Excelente en GPU	Sí	Producción, alto throughput
text-generation-webui	Media	Parcial	Variable	No	Experimentación

LM Studio es probablemente la mejor opción para empezar y para uso personal/profesional en escritorio. Para servir a muchos usuarios o integrar en producción, mira vLLM o un despliegue gestionado.

16. Glosario

LLM: modelo de lenguaje grande.
GGUF: formato de pesos para llama.cpp.
Cuantización: reducción de precisión de los pesos.
Context length: tokens máximos de entrada + salida.
Token: unidad mínima de texto; no equivale a palabra.
Temperature: aleatoriedad de la muestreo.
Top-p: recorte acumulado de probabilidad.
KV cache: memoria de claves/valores para no recalcular el contexto.
GPU offload: capas ejecutadas en GPU.
Embedding: vector que representa significado.
RAG: generación aumentada por recuperación.
LoRA: adaptador de bajo rango para fine-tuning.
MoE: mezcla de expertos; activa solo parte de la red.

17. Recursos

LM Studio: lmstudio.ai
Hugging Face: huggingface.co
Documentación de huggingface_hub: huggingface.co/docs/huggingface_hub
llama.cpp: github.com/ggerganov/llama.cpp
Referencia API OpenAI: platform.openai.com/docs/api-reference