Reemplaza Copilot: Ollama Local En 8GB RAM

¿Será Posible?#

Si estás leyendo esto, probablemente estés buscando una alternativa gratuita y privada a GitHub Copilot. La promesa de la comunidad es atractiva: descarga Ollama, instala una extensión en tu IDE y de repente tienes un asistente de IA local.

Voy a ser directo: si crees que instalar un modelo de 7 mil millones de parámetros (7B) en una máquina con 8GB de RAM te dará la misma fluidez que un clúster de GPUs A100 en la nube, estás operando bajo una falsa premisa. No es un reemplazo “mágico” ni 1:1. Es un entorno de ingeniería de compromisos (trade-offs).

Este post no busca validar la idea de que la IA local en hardware de gama baja es perfecta. Busca diseccionar cómo hacerla funcionar cuando los recursos son críticos, señalando los cuellos de botella reales, la matemática detrás de la memoria y la arquitectura que debes implementar para que el autocompletado no destruya tu flujo de trabajo.

La cruda realidad del Hardware: 8GB RAM y el abismo del Swap#

Para entender por qué tu entorno va a colapsar si no lo configuras correctamente, necesitas entender la aritmética básica de los Modelos de Lenguaje Grande (LLMs).

Un modelo como CodeLlama 7B tiene 7 mil millones de parámetros. En su formato original de coma flotante de 16 bits (FP16), cada parámetro ocupa 2 bytes. 7,000,000,000 * 2 bytes = 14 GB.

Solo cargar los pesos del modelo requiere 14 GB de RAM. Tú que posiblemente tengas 8 GB (como yo). Si intentas ejecutar esto, tu sistema operativo recurrirá al swap (paginación en disco duro o SSD). El swap es órdenes de magnitud más lento que la RAM. El resultado es que tu autocompletado tardará 15 segundos en sugerir un simple console.log. Eso es inaceptable; un autocompletado útil requiere una latencia inferior a los 400 milisegundos.

Anatomía del Autocompletado: FIM (Fill-In-the-Middle)#

Un error fundamental es pensar que el autocompletado funciona igual que un chat (User: Escribe una función... -> AI: Aquí tienes...). El autocompletado de código utiliza una arquitectura específica llamada FIM (Fill-In-the-Middle).

Cuando tu cursor está en medio de un archivo, el IDE no solo envía lo que está arriba del cursor. Envía un prompt estructurado con tokens especiales para que el modelo entienda el contexto anterior y posterior. CodeLlama utiliza este formato:

<PRE> {código_antes_del_cursor} <SUF>{código_despues_del_cursor} <MID>

Si el modelo no soporta FIM de forma nativa (o si configuras mal el prompt template en tu IDE), la IA intentará continuar el código ignorando lo que ya tienes escrito debajo, creando duplicaciones de sintaxis e invalidando bloques enteros de tu aplicación.

Paso 1: Infraestructura de Inferencia (Ollama)#

Ollama es un wrapper en Go alrededor de llama.cpp que maneja la carga del modelo en memoria y expone una API REST local.

curl -fsSL [https://ollama.com/install.sh](https://ollama.com/install.sh) | sh

sudo systemctl stop ollama
# Arrancar solo cuando vayas a usar el IDE
sudo systemctl start ollama

ollama pull codellama:7b-code-q4_K_M

Paso 2: El Cuello de Botella del Contexto (KV Cache)#

Este es el punto ciego más grande que la mayoría pasa por alto. Los LLMs utilizan algo llamado KV Cache (Key-Value Cache) para recordar el contexto de la conversación o el archivo actual.

El tamaño del modelo en disco (3.8 GB) es estático. Pero a medida que pasas más líneas de código al modelo, el KV Cache crece dinámicamente en tu memoria RAM. Un contexto de 8192 tokens (el máximo de CodeLlama) puede consumir fácilmente 1.5 GB adicionales de RAM. En nuestra contabilidad anterior, no tenemos esos 1.5 GB.

Regla de oro para 8GB RAM: Debes limitar la ventana de contexto (Context Window) a 1024 o, como máximo, 2048 tokens. La IA no conocerá todo tu repositorio, pero será capaz de predecir la función actual sin colapsar tu sistema operativo.

Paso 3: Integración con el IDE (Continue.dev)#

Evita las extensiones genéricas que envían peticiones ineficientes. Utilizaremos Continue.dev, una extensión open-source para VS Code y JetBrains que permite un control granular sobre las peticiones HTTP que se hacen a tu servidor local.

Una vez instalada la extensión en tu IDE, abre el archivo config.json de Continue (usualmente en ~/.continue/config.json) y configúralo explícitamente. Ignora la configuración automática y aplica esta arquitectura restrictiva:

{
  "models": [
    {
      "title": "CodeLlama Local (Chat)",
      "provider": "ollama",
      "model": "codellama:7b-code-q4_K_M",
      "apiBase": "[http://127.0.0.1:11434](http://127.0.0.1:11434)",
      "contextLength": 2048,
      "completionOptions": {
        "temperature": 0.2,
        "topP": 0.9,
        "topK": 40
      }
    }
  ],
  "tabAutocompleteModel": {
    "title": "CodeLlama Autocomplete",
    "provider": "ollama",
    "model": "codellama:7b-code-q4_K_M",
    "apiBase": "[http://127.0.0.1:11434](http://127.0.0.1:11434)",
    "contextLength": 1024,
    "completionOptions": {
      "temperature": 0.1,
      "maxTokens": 64
    }
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "useSuffix": true,
    "maxPromptTokens": 512,
    "debounceDelay": 800
  }
}

Puntos Ciegos Adicionales de esta Arquitectura#

Si vas a adoptar este sistema, hazlo con los ojos abiertos. Aquí están las fallas inherentes a este enfoque que la comunidad de “IA Local” rara vez admite:

Conclusión: ¿Vale la pena?#

Reemplazar GitHub Copilot con una configuración local en una máquina de 8GB RAM es un ejercicio de pragmatismo técnico, no una actualización mágica. Funciona, sí, pero exige que moderes tus expectativas y configures agresivamente tus herramientas.

Es una mala idea si tu objetivo principal es la velocidad bruta de desarrollo empresarial. En ese caso, la suscripción de $10/mes de un servicio cloud se paga sola en productividad.

Sin embargo, si tus prioridades son la privacidad absoluta (código bajo NDAs estrictos), operar en entornos air-gapped (sin internet) o entender a bajo nivel cómo se orquestan los LLMs en ambientes con recursos constreñidos, esta arquitectura es invaluable. Te obliga a comprender la gestión de memoria, las arquitecturas de red locales y los límites del hardware actual, conocimientos fundamentales para cualquier Ingeniero de Software que quiera construir sobre, y no solo usar, Inteligencia Artificial.