Guías prácticas

Cómo ejecutar un modelo de programación en local con Ollama

Instale Ollama en macOS, Linux o Windows, elija un modelo adecuado para código, ajuste la ventana de contexto y conecte OpenCode o Cline, según la documentación oficial.

Por Audryk · 20 octubre 2026

• Guías prácticas
• Modelos
• Agentes de programación
• #guías
• #código abierto
• #Ollama

Ollama descarga y ejecuta modelos de lenguaje en su máquina y los ofrece a través de una API local en http://localhost:11434. Un agente de programación puede conectarse a ella y trabajar sin enviar su código a un proveedor de API. Esta guía sigue la documentación de Ollama, verificada el 20-10-2026; los límites de hardware se tratan al final.

Instalar Ollama

macOS: macOS Sonoma (v14) o posterior. Los chips de la serie M de Apple son compatibles con CPU y GPU, los Mac con Intel solo con CPU (Ollama). El método preferido es montar ollama.dmg y arrastrar la aplicación a la carpeta Aplicaciones; al iniciarse, propone enlazar el comando ollama en /usr/local/bin. La página de descarga ofrece también la instalación por línea de comandos, igual que en Linux.

Linux (Ollama):

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

Windows: Windows 10 22H2 o posterior, Home o Pro. La instalación no necesita derechos de administrador, se hace en su directorio personal y ocupa al menos 4 GB (Ollama). Desde PowerShell, según la página de descarga:

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

Después, compruebe que el comando responde:

ollama -v

Prevea espacio en disco: según Ollama, los modelos van de decenas a centenares de gigabytes. En Windows, la variable OLLAMA_MODELS permite almacenarlos fuera de su directorio personal.

Elegir un modelo adecuado para código

La biblioteca de Ollama incluye familias especializadas en código. Dos ejemplos habituales, con cifras de sus páginas oficiales:

• qwen3-coder (Alibaba): la versión 30b pesa 19 GB, tiene 30 000 millones de parámetros de los que 3300 millones están activos (una arquitectura de mezcla de expertos) y acepta 256 000 tokens de contexto. La versión 480b pesa 290 GB y necesita al menos 250 GB de memoria, o de memoria unificada, para ejecutarse en local (Ollama).
• qwen2.5-coder: seis tamaños, de 0.5b (398 MB) a 32b (20 GB), todos con una ventana de contexto de 32 000 tokens (Ollama).

Para descargar y ejecutar qwen3-coder 30B, el comando de su página oficial:

ollama run qwen3-coder:30b

Los modelos capaces de llamar a herramientas, algo que necesita un agente, se pueden filtrar en la biblioteca. La página de un modelo no siempre indica la memoria necesaria: compare el tamaño del archivo con la memoria de su tarjeta gráfica o con la memoria unificada de un Mac.

Ajustar la ventana de contexto

Es el parámetro que más importa para un agente. Por defecto, Ollama elige la ventana de contexto según la memoria de vídeo (VRAM) disponible (Ollama):

• menos de 24 GiB de VRAM: 4000 tokens;
• de 24 a 48 GiB: 32 000 tokens;
• 48 GiB o más: 256 000 tokens.

Ollama recomienda al menos 64 000 tokens para agentes y herramientas de programación. Se ajusta con el control deslizante de los ajustes de la aplicación o al iniciar el servidor:

OLLAMA_CONTEXT_LENGTH=64000 ollama serve

Un contexto mayor consume más memoria. Compruebe dónde se ejecuta el modelo: la columna PROCESSOR debería indicar 100% GPU; un valor como 48%/52% CPU/GPU significa que parte del modelo se ha desbordado a la memoria del sistema, algo que Ollama aconseja evitar para obtener el mejor rendimiento.

ollama ps

Conectar un agente de programación

**La forma más sencilla: ollama launch.** Desde el directorio de su proyecto, Ollama configura e inicia el agente elegido y propone instalarlo si hace falta (Ollama):

ollama launch opencode

El mismo comando existe para Claude Code (ollama launch claude) y para Codex CLI (ollama launch codex, una vez instalado Codex CLI). Después, elija un modelo de la lista.

OpenCode, configuración manual (Ollama). OpenCode requiere una ventana de contexto de 64 000 tokens o más, por lo que los modelos limitados a 32 000 tokens, como qwen2.5-coder, no bastan. Instalación:

curl -fsSL https://opencode.ai/install | bash

npm install -g opencode-ai

Después, declare Ollama como proveedor en opencode.json (ejemplo oficial, con el modelo qwen3.5):

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen3.5": {
          "name": "qwen3.5"
        }
      }
    }
  }
}

Después, ejecute opencode. Nota: ollama launch opencode no sobrescribe ~/.config/opencode/opencode.json.

Cline, en su IDE (Ollama):

1. Abra los ajustes de Cline, sección API Configuration, y establezca API Provider en Ollama.
2. Seleccione un modelo en Model o escriba su nombre.
3. Suba la ventana de contexto a al menos 32 000 tokens en Context Window.

¿Y Continue? Su repositorio de GitHub indica que ya no se mantiene y pasa a ser de solo lectura (consulte nuestro artículo sobre los agentes de programación de código abierto en GitHub). Aider, otro agente de código abierto, también admite un modelo local según su ficha de herramienta.

Límites de hardware

• Tarjetas NVIDIA: capacidad de cómputo 5.0 o superior y controlador 550 o posterior; las tarjetas con capacidad de cómputo de 5.0 a 6.2 necesitan el controlador 570 (Ollama). En Windows, controlador NVIDIA 551.61 o posterior.
• Tarjetas AMD en Windows: pila ROCm v7 / HIP7, o un controlador Radeon compatible con Vulkan; Vulkan es la alternativa recomendada para algunas tarjetas RX 6000.
• Mac: aceleración por GPU solo en los chips de la serie M de Apple; un Mac con Intel funciona con CPU.
• Memoria: para obtener el mejor rendimiento, Ollama aconseja evitar que el modelo, contexto incluido, se desborde de la memoria gráfica a la CPU. Con menos de 24 GiB de VRAM, la ventana por defecto (4000 tokens) es demasiado corta para un agente: hay que ampliarla, a costa de más memoria.
• Disco: cuente con varias decenas de gigabytes por modelo de tamaño medio (19 GB para qwen3-coder 30B).

Un modelo local no cuesta nada por uso, pero sus resultados no son directamente comparables con los de los modelos de frontera: consulte la comparativa de modelos para ver las puntuaciones publicadas por los proveedores.

Para ir más lejos

• Agentes compatibles: OpenCode, Cline, Aider; la comparativa OpenCode, Aider y Cline y el enfrentamiento directo Cline vs OpenCode.
• Modelos de pesos abiertos: la ficha de modelos de código abierto y open weights frente a código abierto en el glosario.
• El coste de las demás opciones: Elegir un agente de programación según el presupuesto.

Fuentes

• Ollama Docs: Quickstart, verificado el 20-10-2026
• Ollama Docs: Linux, macOS y Windows, verificado el 20-10-2026
• Ollama: descarga (comandos de instalación), verificado el 20-10-2026
• Ollama Docs: Context length, verificado el 20-10-2026
• Ollama Docs: Hardware support, verificado el 20-10-2026
• Ollama Docs: OpenCode y Cline, verificado el 20-10-2026
• Ollama: qwen3-coder y qwen2.5-coder, verificado el 20-10-2026

Conclusión clave: Ollama se instala con un solo comando, pero un agente de programación necesita al menos 64 000 tokens de contexto según Ollama, algo que la configuración por defecto solo ofrece a partir de 48 GiB de memoria de vídeo.

¿Ha detectado un error en este artículo? Comuníquenoslo · Nuestra política de correcciones