Cómo usar una IA en local en su ordenador: tutorial paso a paso

Usar una IA en local consiste en descargar un modelo de pesos abiertos y ejecutarlo en su propio ordenador, sin enviar sus textos a un servicio en línea. Con una herramienta como Ollama o llama.cpp, la instalación se resuelve en unas pocas órdenes; la verdadera decisión es qué tamaño de modelo admite su máquina.

Qué significa exactamente «IA en local»

Un gran modelo de lenguaje es un enorme archivo de números llamados pesos. Cuando su desarrollador los publica, se habla de modelo de pesos abiertos: usted puede descargar esos pesos y hacer el cálculo por su cuenta. Ese cálculo, el que produce la respuesta, se llama inferencia.

Hay tres buenos motivos para hacerlo en casa o en la oficina:

• confidencialidad: sus documentos no salen de la máquina;
• coste: no hay factura por token, solo el equipo y la electricidad;
• independencia: el modelo funciona sin conexión y no cambia salvo que usted lo cambie.

La contrapartida es real: menos capacidad que los mejores modelos en línea y algo de configuración. Este tutorial busca un primer resultado concreto: un modelo que responda en su terminal y, después, a sus propios programas.

Requisitos: lo que necesita su máquina

Antes de instalar nada, compruebe tres puntos.

1. El sistema operativo. Según la documentación de Ollama consultada el 22 de octubre de 2026, hace falta Windows 10 22H2 o posterior, o bien macOS Sonoma (versión 14) o posterior. En Mac, los chips Apple de la serie M aprovechan el procesador y la GPU; los Mac con Intel funcionan solo con el procesador. Linux también es compatible.

2. La memoria. Es el criterio decisivo. Para ir rápido, el modelo debe caber en la VRAM, la memoria de la tarjeta gráfica (GPU). Si no, puede ejecutarse desde la memoria RAM, con más lentitud. El tamaño de un modelo depende de su número de parámetros y de su cuantización, es decir, la precisión con la que se guarda cada peso. Los archivos en formato GGUF, el que usan ambas herramientas, suelen estar cuantizados a unos 4 bits.

3. El espacio en disco. La documentación de Ollama para Windows pide al menos 4 GB para el programa, más el espacio de los modelos.

Algunos órdenes de magnitud, tomados de la biblioteca oficial de Ollama el 22 de octubre de 2026 (tamaño de descarga según la variante):

Modelo (etiqueta Ollama)	Tamaño indicado	Equipo adecuado
qwen3.5:4b	3,3 a 4,0 GB	Portátil reciente, incluso sin GPU dedicada
qwen3.5:9b	6,6 a 7,6 GB	Tarjeta gráfica o Mac con memoria holgada
gemma4:e4b	6,6 a 9,5 GB	Igual
gemma4:26b	16 a 19 GB	Máquina bien equipada
qwen3.5:27b	17 a 20 GB	Máquina bien equipada
gemma4:31b	19 a 20 GB	Máquina bien equipada

La columna de la derecha es una lectura nuestra, no un requisito oficial. Deje siempre margen por encima del tamaño del archivo: el modelo necesita memoria de trabajo para el contexto de la conversación.

Elegir un modelo de pesos abiertos

Los desarrolladores publican cada vez más modelos abiertos, de todos los tamaños. La tabla siguiente reúne algunos adecuados para uso local, con los datos del sitio:

Modelo	Desarrollador	Lanzamiento	Contexto (tokens)	Entrada ($/M tokens)	Salida ($/M tokens)	Pesos abiertos
Gemma 4 31B IT	Google DeepMind	2 de abril de 2026	262 k	0,14 US$	0,40 US$	Sí
Gemma 4 26B A4B IT	Google DeepMind	2 de abril de 2026	262 k	0,10 US$	0,34 US$	Sí
Qwen3.6 27B	Alibaba Cloud (Qwen)	22 de abril de 2026	262 k	0,33 US$	2,7 US$	Sí
Qwen3.6 35B-A3B	Alibaba Cloud (Qwen)	17 de abril de 2026	262 k	0,17 US$	1 US$	Sí
Ministral 3 8B 2512	Mistral AI	2 de diciembre de 2025	262 k	0,15 US$	0,15 US$	Sí
Granite 4.2 8B	IBM (Granite)	25 de agosto de 2026	131 k	0,06 US$	0,25 US$	Sí

Los precios que aparecen son los de los proveedores que sirven estos modelos por API: en local no se paga por token. Dos familias se repiten en las herramientas de consumo: Gemma, de Google DeepMind, cuya versión más grande se describe en la ficha de Gemma 4 31B IT, y Qwen, de Alibaba. Los modelos marcados «A4B» o «A3B» usan una mezcla de expertos: solo una parte de los pesos trabaja en cada palabra, lo que acelera el cálculo, aunque todos los pesos deben caber en memoria.

Para situar su nivel, este es el índice de la clasificación de Epoch AI a 22 de octubre de 2026, que combina varias pruebas exigentes, con un modelo cerrado de referencia como comparación:

Índice de capacidad (sobre 100)

• Claude Opus 5.595,9
• Kimi K2.684,4
• Qwen3.6 27B72,2
• Qwen3.6 35B-A3B55,3
• Qwen3.5 9B49,6

Kimi K2.6 tiene pesos abiertos, pero su tamaño lo reserva a servidores. Los modelos que caben en un ordenador personal puntúan claramente por debajo. La lista completa, con licencias, está en nuestra página de modelos de código abierto.

Paso 1: instalar Ollama

Ollama es la vía más sencilla: un programa que descarga los modelos, los mantiene en memoria y los sirve a sus aplicaciones. Las órdenes siguientes proceden de su README oficial.

En macOS o Linux, en una terminal:

curl -fsSL https://ollama.com/install.sh | sh

En Windows, en PowerShell:

irm https://ollama.com/install.ps1 | iex

Si prefiere no ejecutar un script descargado, el mismo README ofrece un instalador clásico para Mac y Windows, además de una imagen Docker oficial. Acostúmbrese a leer un script antes de lanzarlo: es una higiene básica de seguridad.

Paso 2: descargar y ejecutar su primer modelo

Una sola orden descarga el modelo si hace falta y abre una conversación en la terminal:

ollama run gemma4

Sin etiqueta, Ollama elige la variante por defecto, aquí gemma4:e4b según su biblioteca. En una máquina más modesta, elija una etiqueta más pequeña, por ejemplo ollama run qwen3.5:4b. Escriba su pregunta y luego /bye para salir.

Otras órdenes útiles, documentadas en la referencia de la CLI:

ollama pull qwen3.5:9b   # descargar sin ejecutar
ollama ls                # listar los modelos instalados
ollama ps                # ver los modelos cargados en memoria
ollama stop gemma4       # descargar un modelo de la memoria
ollama rm gemma4         # borrar un modelo del disco

Resultado esperado: el modelo empieza a responder en pocos segundos, palabra a palabra. Desactive la wifi y haga otra pregunta: la respuesta llega igual. Es la prueba de que todo ocurre en su máquina.

Paso 3: llamar al modelo desde un programa

Ollama funciona también como servidor de inferencia: según su documentación, su API escucha en http://localhost:11434, solo en su ordenador. Pruébelo con curl, adaptando el ejemplo del README:

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4",
  "messages": [{"role": "user", "content": "Explica el RGPD en tres frases."}],
  "stream": false
}'

Más práctico aún, Ollama ofrece un punto de acceso compatible con el de OpenAI. Según su página de compatibilidad, la biblioteca cliente exige una clave, pero Ollama la ignora:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1/", api_key="ollama")
respuesta = client.chat.completions.create(
    model="gemma4",
    messages=[{"role": "user", "content": "Propón tres títulos para un artículo sobre compostaje."}],
)
print(respuesta.choices[0].message.content)

Este detalle importa: la mayoría de las herramientas pensadas para una API en línea aceptan una dirección base personalizada. La misma página indica que admite la llamada a herramientas, así que puede conectar un modelo local a un framework de agentes. Atomic Agents, por ejemplo, cita Ollama entre sus proveedores. Para seguir, nuestra guía para crear un agente de IA, del no-code al código recorre el proceso completo, y nuestro comparativo de frameworks de agentes de IA le ayuda a elegir herramienta.

Variante: llama.cpp, para controlarlo todo

llama.cpp es el motor sobre el que se apoya Ollama. Usarlo directamente da más ajustes: número de capas en la GPU, tamaño del contexto, archivo GGUF exacto. Según su README consultado el 22 de octubre de 2026, admite los chips Apple (Metal), las GPU NVIDIA (CUDA), AMD (HIP) e Intel (SYCL), Vulkan y el procesador solo, con cuantizaciones de 1,5 a 8 bits.

Instalación, según el README:

# macOS o Linux
curl -LsSf https://llama.app/install.sh | sh

# Windows (PowerShell)
irm https://llama.app/install.ps1 | iex

También hay binarios precompilados, una imagen Docker y compilación desde el código fuente. Después, dos órdenes:

# descargar un modelo de Hugging Face y conversar con él
llama cli -hf ggml-org/Qwen3.5-0.8B-GGUF

# lanzar un servidor compatible con OpenAI, con interfaz web
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUF

El ejemplo usa un modelo diminuto, ideal para comprobar que todo funciona. Según la documentación del servidor, la opción -hf toma por defecto la cuantización Q4_K_M y el servidor escucha en 127.0.0.1, puerto 9931: abra http://localhost:9931 en su navegador para conversar, o apunte sus programas a http://localhost:9931/v1.

Criterio	Ollama	llama.cpp
Primeros pasos	Muy sencillo, una orden por modelo	Más técnico, muchas opciones
Catálogo	Biblioteca de ollama.com, etiquetas listas	Cualquier archivo GGUF, sobre todo en Hugging Face
API	Nativa y compatible con OpenAI, puerto 11434	Compatible con OpenAI, puerto 9931 por defecto
Interfaz	Terminal y aplicación de escritorio	Terminal e interfaz web integrada
Ideal para	Empezar rápido, conectar una aplicación	Ajustar una máquina, probar variantes

Póngase a prueba Su portátil tiene 8 GB de memoria en total y ninguna tarjeta gráfica dedicada. ¿Qué modelo prueba primero?

Uno pequeño, como qwen3.5:4b (3,3 a 4,0 GB en la biblioteca de Ollama) o el modelo de demostración de llama.cpp. Un modelo de 7 GB ocuparía casi toda la memoria, sistema operativo incluido: arrancaría mal o iría muy lento.

Resolver los problemas más frecuentes

• Va desesperadamente lento. Seguramente el modelo no cabe en la memoria de la GPU y se desborda hacia el procesador. ollama ps indica dónde está cargado. Pase a una etiqueta más pequeña o a una cuantización más fuerte.
• «Out of memory» o cierre al cargar. La misma causa, o una ventana de contexto demasiado grande: la memoria de la conversación se suma a la de los pesos.
• El disco se llena. Borre los modelos que no use con ollama rm. En Windows, la variable OLLAMA_MODELS permite guardarlos en otra unidad, según la documentación.
• Respuestas pobres en español. Pruebe un modelo más grande u otra familia: los modelos pequeños suelen manejarse mejor en inglés que en otros idiomas.

Ir más lejos: sus documentos y la seguridad

Un modelo local se vuelve realmente útil cuando trabaja con sus propios archivos. Es la idea del RAG, que da sus documentos a una IA: se buscan los pasajes pertinentes y se entregan al modelo. Ollama expone para ello un punto de acceso de embeddings, según su página de compatibilidad.

En cuanto a seguridad, mantenga el servidor en localhost. Si lo abre a su red, cualquier dispositivo conectado podrá usarlo. Y un modelo local no está a salvo de la inyección de prompts: en cuanto lee contenidos externos y dispone de herramientas, aplique las mismas reglas que a un agente en línea, explicadas en nuestra guía sobre la seguridad de los agentes de IA.