Cómo Usar IA en Local con Ollama (Gratis, Privado y Sin API)

TL;DR: Instala Ollama → descarga un modelo (ollama pull llama4) → úsalo desde terminal, VS Code o tu propia app. Cero coste, cero rate limits, tu código nunca sale de tu máquina.

Requisitos previos

• PC con 16 GB de RAM mínimo (32 GB recomendado)
• 10-30 GB de disco libres (los modelos pesan)
• Windows 10/11, macOS o Linux
• Opcional: GPU con 8+ GB VRAM (NVIDIA recomendada)

---

Estás pagando $20/mes por una API de IA para programar. A veces recibes errores 429 de rate limit. Y encima, cada línea de código que escribes pasa por los servidores de OpenAI o Anthropic.

¿Y si pudieras tener tu propia IA corriendo en tu PC? Sin pagar, sin límites y sin que tu código salga de tu máquina.

Con Ollama es posible. Te enseño cómo montarlo en 10 minutos.

Paso 1: Instalar Ollama

Windows

# Descarga e instala desde la web oficial
winget install Ollama.Ollama

# Verifica la instalación
ollama --version

macOS

brew install ollama

Linux

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

Ollama se ejecuta como servicio local en http://localhost:11434. No necesitas Docker, no necesitas configurar nada.

Paso 2: Descargar un modelo

# El modelo más equilibrado para programar (8B parámetros, ~5 GB)
ollama pull llama4

# Alternativas por caso de uso:
ollama pull deepseek-coder-v3      # Mejor para código (7B, ~4 GB)
ollama pull qwen2.5-coder:7b       # Excelente para Python (7B, ~4 GB)
ollama pull codellama:13b           # Más potente, necesita 16+ GB RAM
ollama pull llama4-scout:17b        # Mejor modelo gratuito 2026 (17B, ~10 GB)

Pro-Tip: Si tienes 32 GB de RAM o una GPU con 12+ GB VRAM, usa modelos de 32B. La diferencia de calidad con los de 7B es enorme, especialmente en debugging y refactoring.

Paso 3: Usarlo desde terminal

# Chat interactivo
ollama run deepseek-coder-v3

# Una sola pregunta (ideal para scripts)
ollama run deepseek-coder-v3 "Escribe un decorador Python para cachear resultados con TTL"

Resultado:

import time
from functools import wraps

def cache_with_ttl(ttl_seconds=300):
    def decorator(func):
        cache = {}
        @wraps(func)
        def wrapper(*args, **kwargs):
            key = (args, tuple(sorted(kwargs.items())))
            if key in cache:
                result, timestamp = cache[key]
                if time.time() - timestamp < ttl_seconds:
                    return result
            result = func(*args, **kwargs)
            cache[key] = (result, time.time())
            return result
        return wrapper
    return decorator

@cache_with_ttl(ttl_seconds=60)
def fetch_data(url):
    # tu lógica aquí
    pass

Funciona. Primera vez. Sin pagar un euro.

Paso 4: Integrar con VS Code

Opción A: Continue (extensión gratuita)

1. Instala la extensión Continue desde VS Code
2. Abre la configuración (~/.continue/config.json):

{
  "models": [
    {
      "title": "DeepSeek Local",
      "provider": "ollama",
      "model": "deepseek-coder-v3"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Autocomplete",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b"
  }
}

3. Ahora tienes autocompletado + chat con IA en VS Code, completamente gratis.

Opción B: Usar Ollama como backend para Cline

Si prefieres Cline (antes Claude Dev), puedes apuntar sus peticiones a Ollama:

{
  "cline.apiProvider": "ollama",
  "cline.ollamaBaseUrl": "http://localhost:11434",
  "cline.ollamaModel": "llama4-scout:17b"
}

Advertencia: Los modelos locales funcionan bien para autocompletado y scripts, pero para edición multi-archivo tipo “Agent” (crear/editar 10 archivos a la vez), los modelos de API siguen siendo mejores. Si necesitas esa funcionalidad, consulta la comparativa Cursor vs Copilot vs Windsurf.

Paso 5: Crear tu propio chatbot local con API

Ollama expone una API REST en localhost:11434 que puedes usar desde cualquier lenguaje:

// Node.js — chatbot local con Ollama
const response = await fetch('http://localhost:11434/api/chat', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'deepseek-coder-v3',
    messages: [
      { role: 'system', content: 'Eres un experto en Python. Responde solo con código.' },
      { role: 'user', content: 'Crea un servidor FastAPI con endpoint /health' }
    ],
    stream: false
  })
});

const data = await response.json();
console.log(data.message.content);

# Python — chatbot local con Ollama
import requests

response = requests.post('http://localhost:11434/api/chat', json={
    'model': 'deepseek-coder-v3',
    'messages': [
        {'role': 'user', 'content': 'Función para validar emails con regex'}
    ],
    'stream': False
})

print(response.json()['message']['content'])

Si quieres llevar esto más lejos y construir un chatbot con RAG (que pueda buscar en tus documentos), mira el tutorial de chatbot RAG con OpenAI — la arquitectura es la misma, solo cambias el proveedor por Ollama.

Comparativa honesta: Ollama vs APIs de pago

Criterio	Ollama (local)	API OpenAI/Anthropic
Coste	$0 (solo electricidad)	$10-100+/mes
Privacidad	100% local	Tu código va a la nube
Rate limits	Sin límites	Error 429 frecuente
Calidad (7B)	⭐⭐⭐	⭐⭐⭐⭐⭐
Calidad (32B+)	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Velocidad	Depende de tu hardware	~80 tokens/s
Offline	✅ Funciona sin internet	❌ Requiere conexión
Multiarchivo/Agent	⭐⭐	⭐⭐⭐⭐⭐

Qué modelo elegir según tu hardware

RAM disponible	GPU VRAM	Modelo recomendado	Calidad
8 GB	Sin GPU	qwen2.5-coder:3b	Básica (autocompletado)
16 GB	Sin GPU	deepseek-coder-v3 (7B)	Buena (scripts, código simple)
16 GB	8 GB NVIDIA	llama4 (8B)	Buena+ (más rápido con GPU)
32 GB	12 GB NVIDIA	llama4-scout:17b	Muy buena (casi nivel API)
32 GB	24 GB NVIDIA	qwen2.5-coder:32b	Excelente (compite con GPT-4.1 mini)
64 GB+	2x GPU	deepseek-v3:67b	Premium (nivel Claude Sonnet)

Pro-Tip: Ejecuta ollama ps para ver cuánta memoria está usando el modelo cargado. Si tu PC se ralentiza, baja a un modelo más pequeño. Ollama descarga los modelos bajo demanda, así que puedes probar varios sin compromiso.

5 cosas que puedes hacer con Ollama que no puedes con APIs

1. Programar en un avión — sin WiFi, tu IA sigue funcionando
2. Código confidencial — proyectos con NDA donde no puedes enviar código a la nube
3. Aprender sin límites — pregunta 1.000 veces al día sin pagar ni recibir rate limits
4. Personalizar modelos — crea Modelfiles con tu propio system prompt persistente
5. Integrar en CI/CD privado — revisa PRs con IA sin exponer tu código

Cuándo NO usar Ollama

Sé honesto: Ollama no es para todo.

• Si necesitas calidad máxima para lógica compleja → usa Claude Opus 4 o GPT-4.1
• Si necesitas editar 20 archivos a la vez con un Agent → usa Cursor o Copilot
• Si tu PC tiene menos de 16 GB de RAM → usa las alternativas gratis en la nube
• Si necesitas modelos multimodales (imágenes) → las mejores IA para generar imágenes son todas en la nube

Ollama es una herramienta más en tu arsenal. El setup ideal en 2026 es: Ollama para el 70% de tareas + API de pago para el 30% complejo.

---

¿Tienes otro modelo local favorito que no mencioné? Compártelo en LinkedIn.