1. Introducción

Voy a hacerte una pregunta incómoda: ¿sabes cuánto te gastas al mes en IA de pago?

Suma la suscripción del chat, las llamadas a la API, ese servicio que probaste y se renueva solo... Cuando echas cuentas de verdad, a más de uno le sale un susto. Y la tendencia va hacia arriba: las APIs no van a bajar de precio, y cada vez metemos IA en más cosas.

Aquí va la idea que mueve toda esta web: para una buena parte de lo que usamos la IA a diario, no necesitamos pagar nada. Resumir, redactar un email, reescribir un texto, clasificar, generar ideas, ayudarnos con código... todo eso lo puede hacer un modelo que corre en tu propio equipo, gratis, sin límite de tokens y sin que tus datos salgan de tu máquina.

Y no, no hablamos de algo cutre de hace dos años. En 2026 tenemos modelos abiertos como Qwen 3, Gemma 4 o Llama 4 que, en tu portátil, te resuelven el día a día sin despeinarse. Lo notas: respuesta instantánea, sin "estás en la cola", sin contador de tokens corriendo.

En este artículo montamos un ChatGPT privado, en local, en una sola tarde. Con su interfaz bonita, conectado a tu código y combinándolo con la IA de pago solo cuando de verdad hace falta.

¡Vamos a ello!

2. Prerrequisitos

Para esto necesitamos bastante poco:

• Un equipo normal. Con 8 GB de RAM ya empezamos; con 16 GB vamos sobrados para el día a día.
• Windows, Mac o Linux. Da igual, Ollama funciona en los tres.
• 20 minutos para descargar el primer modelo (pesa unos GB).
• Ganas de dejar de mirar el contador de tokens.

No hace falta GPU de 2.000 €, ni cuenta en ningún sitio, ni tarjeta de crédito. Todo corre en tu casa.

3. ¿Qué vamos a montar?

En resumen, estas son las piezas que vamos a juntar:

• Ollama: el motor que descarga y ejecuta los modelos.
• Un modelo abierto (Qwen 3, por ejemplo): el cerebro que piensa y responde.
• Open WebUI: una interfaz de chat clavada a ChatGPT, pero en tu navegador y 100% local.
• La API local: para enchufar la IA a tus scripts y automatizaciones.

Visto en conjunto, queda así:

Fíjate en lo importante: no hay ninguna flecha que salga a internet. Tu pregunta entra, el modelo la procesa en tu equipo y la respuesta sale. Punto. Eso es justo lo que en esta web nos gusta: cero coste por token y cero datos viajando por ahí.

4. Paso 1: instalar Ollama

Ollama es lo que hace que todo esto sea fácil. Se encarga de descargar el modelo, usar tu GPU si la tienes y levantar una API local sin que tú toques nada raro.

4.1. Cómo instalarlo paso a paso

1. Entra en la documentación oficial de Ollama y descarga el instalador para tu sistema.
2. Instálalo como cualquier otro programa.
3. Abre una terminal.
4. Lanza tu primer modelo con un solo comando:

ollama run qwen3:8b

La primera vez se descarga el modelo (unos GB, paciencia). Cuando termina, te deja hablar con él ahí mismo, en la terminal:

Y ya está. Sí, así de simple. Eso que estás viendo es un modelo de IA corriendo en tu equipo, respondiendo sin enviar nada a internet y sin cobrarte un céntimo.

Un par de comandos que te vendrán bien:

ollama list          # ver los modelos que tienes
ollama pull gemma3:4b   # descargar otro modelo
ollama rm qwen3:8b   # borrar uno para liberar espacio

5. Paso 2: elegir tu modelo según la RAM

Aquí está la pregunta del millón: ¿qué modelo descargo? Y la respuesta honesta es: el que te entre con holgura en la RAM, no el que tenga mejor fama.

Un modelo enorme que va a tirones no sirve de nada. Es mejor uno mediano que vuele. Esta es la chuleta que yo seguiría a junio de 2026:

Resumiendo:

5.1. Si tienes 8 GB de RAM

Tira de modelos de 3B-4B como qwen3:4b, gemma3:4b o llama3.2:3b. Van de sobra para resumir, clasificar, reescribir y tareas del día a día.

5.2. Si tienes 16 GB de RAM (el punto dulce)

qwen3:8b y para casa. Es el equilibrio perfecto entre listo y ligero: te sirve como asistente general y además se defiende muy bien con código. Si solo vas a instalar un modelo, instala este.

¿Necesitas que razone más (matemáticas, lógica, problemas de varios pasos)? Prueba un modelo de razonamiento como deepseek-r1:8b.

5.3. Si tienes 32 GB o más

Aquí ya puedes con qwen3:32b, gemma4:27b o llama4-scout. Esto es nivel "doy servicio a todo mi equipo" o "monto un RAG serio con mis documentos".

La regla que aplico siempre:

No te enamores del nombre del modelo. Descarga dos, pásales tus tareas reales y quédate con el que vaya fino en TU equipo. La mejor IA local es la que no te hace esperar.

6. Paso 3: tu ChatGPT privado con Open WebUI

Hablar con el modelo desde la terminal está bien para probar, pero seamos sinceros: queremos algo que se parezca a ChatGPT. Eso es Open WebUI: una interfaz de chat que se conecta a Ollama y te da historial de conversaciones, varios modelos, subida de archivos... todo en tu navegador y sin salir de tu equipo.

6.1. Cómo ponerlo en marcha

La vía más cómoda es con Docker. Con Ollama ya corriendo, lanzas:

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

Después:

1. Abre http://localhost:3000 en el navegador.
2. Crea tu usuario (es local, se queda en tu equipo).
3. Arriba selecciona el modelo, por ejemplo qwen3:8b.
4. Empieza a chatear.

Y te encuentras con esto, que reconocerás al instante:

Mismo aspecto que el chat de pago, misma comodidad. La diferencia es que aquí no hay suscripción, no hay límite de mensajes y nada de lo que escribes se va a un servidor ajeno. Para gente del equipo que no es técnica, esto es oro: usan "el ChatGPT de la empresa" sin que ningún dato sensible salga de la oficina.

7. Paso 4: conectarlo a tu código

Aquí es donde la cosa se pone seria de verdad. Ollama no es solo un chat: levanta una API local en http://localhost:11434, y además es compatible con el formato de OpenAI. ¿Qué significa eso? Que puedes reutilizar el mismo código que ya usas para la IA de pago, cambiando solo dos líneas.

Mira qué bonito. Instalas la librería:

pip install openai

Y apuntas al modelo local en vez de a un servicio de pago:

from openai import OpenAI

# Apuntamos a Ollama en local, no a la nube
cliente = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # da igual lo que pongas, es local
)

respuesta = cliente.chat.completions.create(
    model="qwen3:8b",
    messages=[
        {"role": "system", "content": "Eres un asistente claro y directo."},
        {"role": "user", "content": "Resume este email en 3 puntos: ..."},
    ],
)

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

Eso es todo. Ese script funciona, no envía nada a internet y no te cuesta un euro por mucho que lo ejecutes mil veces. Imagina lo que esto significa para una automatización que procesa cientos de textos al día: lo que antes era una factura, ahora es gratis.

¿Y si prefieres no depender de ninguna librería? La API cruda también es sencilla:

import requests

respuesta = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "qwen3:8b",
        "stream": False,
        "messages": [{"role": "user", "content": "Dame 5 ideas de post para LinkedIn"}],
    },
    timeout=120,
)

print(respuesta.json()["message"]["content"])

8. Paso 5: el enfoque híbrido (local + pago)

Ahora la parte honesta, porque en esta web no vendemos humo: la IA local no lo sustituye todo. Un modelo de 8B que corre en tu portátil no razona como el último modelo gigante de pago. Y no pasa nada.

La jugada inteligente no es "todo local" ni "todo pago". Es híbrida:

• Lo mecánico y repetitivo → local (gratis y privado).
• Lo difícil, ambiguo o crítico → pago (pagas por inteligencia de verdad).

¿Dónde pongo yo la línea?

Si el fallo se detecta rápido y se corrige fácil, va a local. Si el fallo cuesta dinero, reputación o seguridad, paga calidad.

Y esto se puede automatizar con una función pequeña que decida sola por dónde mandar cada tarea:

def elegir_modelo(tarea):
    if tarea["riesgo"] == "alto":
        return "pago"
    if tarea["tipo"] in {"resumen", "clasificacion", "reescritura", "extraccion"}:
        return "local"
    if tarea["tokens"] > 8000:   # texto largo: que lo prepare local primero
        return "local"
    return "pago"

La gracia es que el 80% de las consultas del día a día caen en "local" y se resuelven gratis. Solo el 20% difícil llega al modelo de pago. Ahí es donde está el ahorro de verdad.

Si quieres profundizar en cómo repartir tareas y montar un router automático, lo tienes detallado en el resto de labs de la web.

9. ¿Cuánto te ahorras de verdad?

Vamos a los números, que es lo que mueve esto. Pensemos en alguien que usa IA de forma intensiva: suscripciones premium, llamadas a API en sus automatizaciones, etc. Es fácil irse a unos 200 € al mes. Al año:

IA de pago (uso intensivo):   ~200 €/mes  ->  ~2.400 €/año
IA local:                     luz + equipo ya amortizado  ->  ~0 €

Ojo, no es magia: el equipo cuesta dinero y la luz también. Pero si ya tienes un portátil decente, el coste extra de mover a local buena parte de tus tareas es prácticamente cero. Y cada mes que pasa, el ahorro se acumula.

Y hay un segundo ahorro que no sale en la factura pero que cada vez vale más: la privacidad. Tus contratos, los datos de tus clientes, tu código... no salen de tu equipo. Con la EU AI Act apretando a partir de agosto de 2026 sobre los sistemas de alto riesgo, para sectores como legal, salud o banca esto ya no es un extra simpático: empieza a ser un requisito.

Tres columnas que yo apuntaría siempre:

• Coste: con local, baja a casi cero.
• Privacidad: tus datos se quedan en casa.
• Calidad: para el día a día va sobrado; para lo difícil, escalas a pago. Lo mejor de los dos mundos.

10. Extras

10.1. Dale personalidad a tu asistente

Con un Modelfile puedes crear tu propia versión del modelo con instrucciones fijas, para que siempre responda como tú quieres:

FROM qwen3:8b
SYSTEM Eres el asistente de redacción de salvatustokens. Respondes en español, claro y directo, sin rodeos.
PARAMETER temperature 0.4

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

10.2. También entiende imágenes

Modelos como gemma3:4b o las variantes con visión aceptan imágenes directamente. Puedes pasarle una captura y pedirle que la resuma o extraiga el texto, todo en local.

10.3. Mídelo con tus tareas, no con benchmarks

Un modelo puede ir muy arriba en un ranking y fallar justo en lo tuyo. Coge 20 ejemplos reales de tu día a día, pásaselos y decide con eso. La mejor métrica es "¿me resuelve MIS tareas?".

10.4. No lo cierres al apagar

Ollama puede quedarse corriendo de fondo para que el asistente esté siempre listo. Y si te quedas sin internet, sigue funcionando igual. Esa sensación de "mi IA no depende de nadie" engancha.

11. Quiero el montaje completo

La receta, de principio a fin:

1. Ollama instalado.
2. Un modelo acorde a tu RAM (qwen3:8b si tienes 16 GB y solo quieres uno).
3. Open WebUI para tener tu ChatGPT privado en el navegador.
4. La API local conectada a tus scripts con dos líneas de código.
5. Un router híbrido que mande lo fácil a local y lo difícil a pago.
6. Una medición mensual de coste, privacidad y calidad.

Con esto tienes una IA que es tuya de verdad: rápida, privada, sin contador de tokens y montada en una tarde. No es renunciar a la IA de pago, es dejar de pagarla para lo que no hace falta.

Y esa, al final, es la idea de toda esta web: que la IA trabaje para ti sin vaciarte la cartera.