Tu primer modelo de IA local en 30 minutos

Hay dos razones para ejecutar un modelo de lenguaje en tu propio ordenador. Una es la privacidad, y en Alemania eso pesa más que en otros sitios. La otra es que quieres ver por ti mismo qué es realmente esta cosa cuando no hay una empresa por medio. Ambas son buenas razones.

Lo que obtienes es un modelo que responde sin conexión. Sin cuenta, sin facturación por token, sin transferencia a un proveedor. Lo que no obtienes es la calidad de Opus 5 o GPT-5.6. Eso no es poca cosa, y en el paso 9 digo con claridad dónde está el límite. Pero para una cantidad sorprendente de tareas lo local basta, y llegar ahí lleva media hora.

1. Comprueba primero si tu ordenador da la talla

Antes de instalar nada, mira cuánta memoria tienes. En un Mac con Apple Silicon cuenta la memoria compartida, es decir el número que ponía 16 GB o 32 GB al comprarlo. En un ordenador con Windows o Linux y tarjeta gráfica dedicada cuenta la memoria de esa tarjeta, no la del equipo.

El orden de magnitud, a fecha de agosto de 2026, separado por tipo de equipo. Con una tarjeta gráfica dedicada dispones de casi toda su memoria: 8 GB bastan para un modelo pequeño, 16 GB son cómodos, a partir de 24 GB se pone serio en contenido. En Apple Silicon procesador y gráfica comparten la misma memoria y solo una parte va al modelo, en torno a dos tercios o tres cuartos. De 16 GB salen unos 11 GB utilizables, de 32 GB unos 22. En un Mac, calcula por tanto un escalón más generoso que el número de la caja. Sin tarjeta gráfica también va, solo que más lento, porque calcula el procesador principal.

Consejo: Si dudas, empieza igualmente. El primer intento no te cuesta nada salvo espacio en disco, y eso lo recuperas con un comando.

2. Instala Ollama

Ollama es la entrada más cómoda. Descarga modelos, se ocupa del formato y expone una interfaz que a otros programas les parece la de OpenAI. Eso es más práctico de lo que suena, porque permite que muchas herramientas hablen con tu modelo local sin reformas.

En ollama.com hay instaladores para Mac, Windows y Linux. Tras instalar, un pequeño servicio corre en segundo plano, accesible por defecto solo desde tu propio ordenador. Puedes comprobarlo desde la terminal:

ollama --version

Consejo: Si prefieres una interfaz para hacer clic antes que una terminal, usa LM Studio. Hace lo mismo y tiene un navegador de modelos integrado. Ojo con los comandos de más abajo: LM Studio arranca su servidor a mano desde la interfaz y escucha en un puerto distinto al de Ollama. La dirección aparece allí en la pestaña del servidor, y esa es la que va en el paso 8 en lugar de la de Ollama. Los comandos ollama valen solo para Ollama.

3. Descarga un primer modelo adecuado

Empieza pequeño. Un modelo de siete a nueve mil millones de parámetros con la compresión habitual cabe en ocho gigabytes y responde con fluidez en un ordenador normal.

ollama pull qwen3:8b

La descarga son unos gigabytes. Mientras tanto puedes leer el paso 4.

Consejo: El número antes de la b son miles de millones de parámetros, o sea la clase de tamaño. Lo que va detrás, algo como q4_K_M, es la compresión. Más sobre eso en Qué modelo local encaja con tu hardware.

4. Entiende en una frase qué es la cuantización

Un modelo se entrena con números muy precisos. Para ejecutarlo, esos números pueden guardarse de forma más basta, parecido a guardar una foto como JPEG en vez de RAW. El resultado es más pequeño y más rápido, y la mayoría de las veces no se nota la diferencia.

El ajuste habitual se llama Q4_K_M. Frente al original sin comprimir, la memoria necesaria baja aproximadamente a una cuarta parte, y la pérdida de calidad es tan pequeña que en el día a día no salta a la vista. No son exactamente cuatro bits por número, se suman valores de escala, por eso el tamaño real del archivo siempre queda algo por encima del cálculo puro. Ollama lo elige automáticamente, no tienes que configurar nada. Lo importante es que sepas de qué se habla cuando leas la etiqueta en algún sitio.

Consejo: No bajes de Q4. Q2 y Q3 ahorran más memoria, pero ahí el modelo empieza a volverse notablemente más torpe. Cuánto depende del modelo y de la tarea, y con código y llamadas a herramientas se degrada antes que con prosa.

5. Habla con el modelo por primera vez

ollama run qwen3:8b

Aterrizas en un chat en la terminal. Haz una pregunta cuya respuesta ya conozcas, para poder juzgar la calidad. Algo de tu propio campo funciona mejor que una pregunta de cultura general, porque en lo técnico notas enseguida si hay sustancia o solo suena bien.

Sales con /bye.

Consejo: La primera respuesta tarda más porque el modelo se carga en memoria. A partir de la segunda va ágil. Así que si al principio piensas que esto es inservible de lento, espera al segundo intento.

6. Pon una interfaz delante

Chatear en la terminal está bien para probar e incómodo para el día a día. Open WebUI te da una interfaz en el navegador que parece la de los servicios de chat habituales, pero corre entera en tu ordenador. Reconoce tus modelos de Ollama por sí sola.

Con Docker es un comando, pero en Mac y Windows se ve distinto que en Linux. La diferencia no es cosmética: Ollama escucha solo en 127.0.0.1, y un contenedor no alcanza por sí solo esa dirección del anfitrión.

En Mac y Windows, Docker Desktop crea el nombre host.docker.internal, con el que el contenedor alcanza al anfitrión. El comando va aquí en una sola línea para que se pegue igual de bien en Terminal, PowerShell y símbolo del sistema:

docker run -d -p 127.0.0.1:3000:8080 --add-host=host.docker.internal:host-gateway -e OLLAMA_BASE_URL=http://host.docker.internal:11434 -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:v0.6.31

Lo importante es el -p 127.0.0.1:3000:8080: con eso la interfaz solo es accesible desde tu propio ordenador.

En Linux ese nombre no existe, y la salida que se lee en todas partes es una trampa. --network=host sí deja al contenedor alcanzar el Ollama de 127.0.0.1, pero elimina la atadura a localhost: la interfaz pasa entonces a escuchar en todas las interfaces. Poner un cortafuegos delante suena a solución pero no es fiable, porque ufw status: active no dice nada sobre si ese puerto concreto está cerrado. Y el riesgo es concreto: en una instalación nueva de Open WebUI, la primera persona que se registra se convierte en administradora. Quien esté en la misma red pudo llegar antes.

Por eso esa vía no aparece aquí. En Linux usa la imagen que ya trae Ollama:

docker run -d -p 127.0.0.1:3000:8080 -p 127.0.0.1:11435:11434 -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Ese contenedor tiene su propio Ollama, así que no hay que pasar nada al anfitrión, y ambas ataduras a 127.0.0.1 aguantan sin cortafuegos alguno. El segundo puerto expone la interfaz de Ollama del contenedor, que necesitas en el paso 8. Está a propósito en 11435 y no en 11434, para que no choque con un Ollama que siga instalado en el equipo. Los modelos los descargas aquí desde la interfaz o con docker exec -it open-webui ollama pull qwen3:8b. El Ollama del paso 2 ya no hace falta para la interfaz; para los pasos 3 a 5 en la terminal sí fue útil, y puedes dejarlo o desinstalarlo.

Quien no quiera ni Docker ni dos Ollamas, que use LM Studio en Linux. Trae interfaz y gestión de modelos en uno.

Después abre http://localhost:3000 en el navegador. La versión fija en el comando de Mac y Windows es intencionada: :main se mueve bajo tus pies. La etiqueta :ollama de Linux también se mueve, ahí no hay equivalente fijo. Fijar un build de forma exacta solo se consigue con su digest.

Consejo: A más tardar aquí merece la pena tener una conversación con un encargo real en vez de con preguntas de prueba. Solo entonces notas si el modelo te vale.

7. Dale al modelo tus propios documentos

El punto donde los modelos locales se vuelven interesantes no es el conocimiento general. Ahí pierden frente a los grandes proveedores. Se vuelve interesante cuando ven algo que no quieres dar a ningún proveedor.

Arrastra un PDF al chat en Open WebUI y pide un resumen. Un contrato, un acta, una factura. Justo las cosas ante las que dudas un momento con ChatGPT.

Antes de meter algo realmente sensible, una salvedad. Local es el modelo, no automáticamente toda la interfaz. Si allí está activada la búsqueda web, hay configurado un servicio de embeddings en la nube para buscar en documentos o hay registrado un modelo ajeno como alternativa, partes de tus datos sí salen. Repasa una vez los ajustes y apaga lo que apunte hacia fuera. Después sí vale la frase de que el archivo no sale del ordenador.

Consejo: Al principio mantén los documentos cortos. No porque los modelos pequeños tengan de por sí una ventana de contexto pequeña, eso depende del modelo y no del número de parámetros, sino porque los documentos largos se trocean y se leen solo por fragmentos. En un contrato de 80 páginas eso significa que el resumen puede omitir una cláusula importante sin avisar. Así que contrasta por muestreo los documentos largos con el original.

8. Haz el modelo accesible para otros programas

Ollama expone su interfaz en el puerto 11434 y habla el formato que la mayoría de herramientas conocen de OpenAI. Con eso, en muchos programas basta con cambiar la dirección y de repente la misma aplicación corre contra tu modelo local.

El comando de abajo vale para el Ollama de tu equipo. Con el contenedor de Linux que trae Ollama incluido es la misma interfaz, solo que en el puerto que expusiste en el paso 6: allí pones 11435 en vez de 11434. Lo demás no cambia.

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen3:8b","messages":[{"role":"user","content":"Di hola"}]}'

Si llega una respuesta, la interfaz está abierta y puedes seguir construyendo.

Consejo: Por defecto el puerto solo es accesible desde tu propio ordenador, y está bien así. Si lo abres a la red, piensa antes quién más está en esa red.

9. Espera lo correcto o te decepcionarás

Aquí va la valoración honesta, sin la cual este playbook estaría incompleto.

Lo que va bien en local: resumir, reformular, traducir, ordenar, clasificar, sacar la estructura de un texto, preguntas sencillas sobre un documento adjunto. O sea, toda la parte laboriosa del trabajo con textos.

Lo que va peor en local: cadenas largas de razonamiento, arquitectura de software difícil, trabajar de forma autónoma a lo largo de muchos pasos, todo lo que exige pensar de verdad en profundidad. Ahí los modelos grandes no son un poco mejores, son claramente mejores.

Esto no es una debilidad pasajera que se arregle la semana que viene. Es el precio de que algo corra en un aparato que está bajo tu escritorio en vez de en un centro de datos. Quien lo acepta tiene una herramienta muy útil. Quien espera un sustituto de Opus 5 lo dejará a los dos días.

Consejo: El montaje más productivo suele ser mixto. Local para todo lo que lleve datos sensibles y para el trabajo en masa, nube para los casos duros. Las cuentas están en Local o nube, las cuentas honestas.

10. Recoge si no quieres quedártelo

Los modelos ocupan sitio, y al probar se acumulan varios rápido. Con el Ollama de tu equipo va así:

ollama list
ollama rm qwen3:8b

Con el contenedor de Linux que trae Ollama incluido, los mismos comandos pero dentro del contenedor:

docker exec -it open-webui ollama list
docker exec -it open-webui ollama rm qwen3:8b

En ambos casos eso quita solo el modelo. Tus documentos subidos, los historiales de conversación y los índices de búsqueda están en otro sitio, en el área de datos de la interfaz. Justo el material por el que trabajaste en local. Quien borra solo el modelo y cree haber recogido, deja ahí los contratos y los informes médicos.

Del todo fuera es así:

docker rm -f open-webui
docker volume rm open-webui

Si en Linux usaste el contenedor con Ollama incluido, allí queda una segunda copia de los modelos en su propio volumen:

docker volume rm ollama

En LM Studio el equivalente está en la carpeta del programa dentro de tu directorio de usuario; ahí van también los chats y los archivos adjuntos.

Con eso tus contenidos desaparecen. Lo que queda es infraestructura: la imagen de Docker, la instalación de Ollama y los modelos que aún no hayas quitado. Nada de eso contiene tus documentos, pero ocupa sitio. Lo que no hay: una cuenta que cancelar o una suscripción que siga corriendo. Esa es la otra cara agradable de lo local.

Consejo: Antes de borrar, apunta qué modelo iba bien para qué tarea. Esa nota vale más la próxima vez que el modelo en sí, porque la oferta cambia cada pocos meses.

Qué sigue

Si ahora quieres saber qué modelo da el mejor resultado en tu hardware concreto, sigue en Qué modelo local encaja con tu hardware. Si quieres usarlo en la empresa, IA local y el RGPD aclara qué se aplica de verdad y qué solo se afirma. Y si tu modelo local no solo debe hablar sino también usar herramientas, MCP con modelos locales enseña la conexión con el resto de tu montaje.

Source

Las cifras sobre memoria necesaria y tamaños de modelo cambian con cada generación. Compruébalas en la fuente antes de una decisión de compra, no en blogs.

• Ollama, instalación y biblioteca de modelos: https://ollama.com
• LM Studio, interfaz de escritorio con servidor local: https://lmstudio.ai
• Open WebUI, interfaz de navegador para modelos locales: https://openwebui.com
• llama.cpp, el motor bajo Ollama: https://github.com/ggml-org/llama.cpp