Reemplaza GitHub Copilot: Ollama + Continue.dev

laptop_mac macOS Sonoma Intermediate schedule 8 min read

by Alex Rivera • May 14, 2024

Step 1 El Costo del Autocompletado en la Nube vs. IA Local

Cada tecla que escribes en VS Code con GitHub Copilot activo se transmite a la infraestructura de OpenAI alojada en Azure de Microsoft. Eso no es una teoría conspirativa — es la arquitectura de producto documentada. Tus algoritmos propietarios, la lógica de negocio interna, las funcionalidades no publicadas y las decisiones arquitectónicas están abandonando tu máquina. Para desarrolladores individuales trabajando en proyectos personales, esta compensación suele ser aceptable. Para equipos que construyen software comercialmente sensible, representa un riesgo material de seguridad y cumplimiento normativo.

Luego está la dimensión financiera.

La Realidad del Precio de GitHub Copilot

Para una organización de ingeniería de tamaño mediano con 50 desarrolladores en el nivel Business, estás contemplando $11,400 por año — pagados indefinidamente, a un proveedor externo, sin propiedad sobre el modelo subyacente ni garantía de estabilidad de precios. Microsoft ya ha revisado los precios de Copilot al alza desde su lanzamiento, y no existe razón estructural para esperar que esa tendencia se revierta.

Qué Significa "IA Local" en la Práctica

Ejecutar un modelo local mediante Ollama cambia la ecuación por completo. El costo de cómputo es tu hardware existente. El modelo de privacidad es absoluto — ningún dato abandona tu máquina. La latencia es a menudo inferior a la del autocompletado basado en la nube, porque eliminas el overhead de red de ida y vuelta hacia servidores de inferencia remotos.

Cloud Copilot flow:
Keypress → VS Code → HTTPS → Azure OpenAI → Inference → Response → VS Code

Local Ollama flow:
Keypress → VS Code → localhost:11434 → Inference → Response → VS Code

La ruta de inferencia a través de localhost elimina toda una categoría de modos de fallo: interrupciones de API, limitación de tasa, interferencia de proxies corporativos y varianza de latencia geográfica. Los desarrolladores detrás de firewalls empresariales estrictos que anteriormente no podían usar Copilot en absoluto, ahora pueden ejecutar un modelo de código completamente capaz sin tocar el perímetro de red.

Los Costos Ocultos de la Dependencia en la Nube

Más allá de las tarifas de licencia, el autocompletado en la nube introduce un acoplamiento operacional que es fácil de subestimar:

• Dependencia del proveedor: El flujo de trabajo de tu equipo se vuelve dependiente de un servicio de terceros con control unilateral sobre precios, disponibilidad y términos de servicio.
• Sobrecarga de cumplimiento: Muchas industrias reguladas (salud, finanzas, defensa) requieren acuerdos formales de procesamiento de datos y revisiones de seguridad para cualquier herramienta que transmita código externamente. El proceso de aprobación de Copilot no es trivial en estos entornos.
• Filtración de ventana de contexto: Los modelos en la nube reciben no solo tu archivo actual, sino los búferes de contexto circundantes — archivos adyacentes, pestañas abiertas recientemente y metadatos del repositorio según la configuración.
• Brechas en la trazabilidad: Cuando las sugerencias de código provienen de una caja negra externa, atribuir la procedencia de la propiedad intelectual se vuelve complicado en litigios o disputas de licencias.

Dónde los Modelos Locales Son Competitivos Hoy

Los modelos cuantizados modernos como Code Llama 13B y StarCoder2 7B ejecutándose en hardware de consumo logran una calidad de autocompletado genuinamente competitiva con Copilot para los escenarios de autocompletado más comunes: generación de boilerplate, completado de firmas de funciones, scaffolding de pruebas e implementaciones de algoritmos comunes. La brecha se estrecha aún más cuando el modelo opera sobre código en lenguajes y patrones para los que fue específicamente entrenado.

El cálculo es directo: costo marginal cero, soberanía total de los datos y sin dependencias externas versus una factura de SaaS creciente y un acuerdo implícito de compartir tu base de código con un proveedor de inferencia en la nube. Para equipos serios respecto a la propiedad a largo plazo de su cadena de herramientas, el enfoque local-first no es un compromiso — es la elección arquitectónica más defendible.

Step 2 Requisitos Previos: VS Code y Ollama

Antes de adentrarte en la configuración, necesitas tener dos componentes fundamentales verificados y funcionando. Saltarse la validación adecuada de los requisitos previos es la razón más común por la que los desarrolladores pierden horas depurando lo que debería ser una configuración de IA local sencilla. Hazlo bien, y todo lo que viene después se vuelve mecánico.

Visual Studio Code

Necesitas VS Code 1.80 o posterior. La extensión Continue.dev depende de las APIs modernas de VS Code para las sugerencias de texto fantasma en línea, y las versiones más antiguas fallarán silenciosamente o producirán un comportamiento degradado.

Verifica tu versión desde la línea de comandos:

code --version

Salida esperada (la tuya puede ser más reciente):

1.89.1
e170252f762678dec6ca2cc69aba1864a9a1f8ad
x64

Si estás usando un fork como VSCodium, Continue.dev es totalmente compatible — solo asegúrate de obtener la extensión desde el Open VSX Registry en lugar del Microsoft Marketplace, ya que VSCodium no incluye el host de extensiones propietario de Microsoft por defecto.

Ollama

Ollama es el entorno de ejecución de modelos locales que gestiona las descargas de modelos, la administración de cuantización y expone una API REST compatible con OpenAI en localhost:11434. Esta capa de compatibilidad es precisamente la razón por la que Continue.dev se integra con él de manera tan limpia — no se requiere arquitectura de plugins personalizada.

Instalación por plataforma:

Tras la instalación, inicia el daemon de Ollama:

ollama serve

En macOS, Ollama se ejecuta automáticamente como una aplicación en la barra de menú tras la instalación. En Linux, es posible que quieras configurarlo como un servicio systemd:

sudo systemctl enable ollama
sudo systemctl start ollama

Verifica que la API está activa:

curl http://localhost:11434/api/tags

Una respuesta exitosa devuelve un objeto JSON listando tus modelos instalados localmente. Una lista vacía es perfectamente válida en esta etapa — la descarga de modelos viene en un paso posterior.

{
  "models": []
}

Consideraciones de Hardware

Aquí es donde la mayoría de los tutoriales te dejan sin respuestas. Tu hardware determina directamente qué modelos son viables y a qué nivel de cuantización.

Ollama descarga automáticamente capas a tu GPU mediante Metal (Apple Silicon), CUDA (NVIDIA) o ROCm (AMD). No se requiere configuración manual — Ollama detecta tu hardware y optimiza la descarga de capas de forma transparente.

Nota crítica para usuarios de Apple Silicon: La memoria unificada se comparte entre CPU y GPU. Un MacBook Pro M3 con 16 GB puede ejecutar un modelo de 13B cómodamente porque no existe un límite de VRAM dedicada. Este es uno de los argumentos más sólidos a favor de Apple Silicon en flujos de trabajo de IA local.

Confirmando Tu Entorno

Ejecuta esta verificación rápida antes de continuar:

# Confirm VS Code version
code --version

# Confirm Ollama is running and responsive
curl -s http://localhost:11434/api/tags | python3 -m json.tool

# Confirm GPU acceleration (Ollama logs)
ollama run llama3.2:1b "say ok"

Observa la salida del terminal de Ollama durante la inferencia del modelo. Deberías ver conteos de descarga de capas referenciando tu GPU. Si todo se ejecuta en CPU, revisa la instalación de tus drivers antes de descargar modelos de código más grandes.

Con ambos requisitos previos confirmados, estás listo para instalar Continue.dev y conectar todo.

Step 3 Paso 1: Instalación de la Extensión Continue.dev

Continue.dev es la piedra angular de toda esta configuración — un asistente de código AI de código abierto que actúa como reemplazo directo de GitHub Copilot, pero con una diferencia arquitectónica crítica: enruta tus solicitudes a donde tú le indiques, incluyendo una instancia de Ollama ejecutándose localmente. Sin telemetría. Sin egreso a la nube. Sin suscripción.

Instalación desde el Marketplace de VS Code

La ruta de instalación más sencilla pasa directamente por el Marketplace de Extensiones de VS Code dentro del editor:

1. Abre VS Code
2. Presiona Ctrl+Shift+X (Windows/Linux) o Cmd+Shift+X (macOS) para abrir el panel de Extensiones
3. Busca "Continue"
4. Localiza la extensión publicada por Continue (el icono es un logotipo distintivo con degradado violeta)
5. Haz clic en Install

Alternativamente, instálala desde la línea de comandos usando el CLI de VS Code:

code --install-extension Continue.continue

O si estás usando VS Codium (el fork sin telemetría), la extensión está disponible en el Open VSX Registry:

codium --install-extension Continue.continue

Nota: Continue.dev también es compatible con IDEs de JetBrains (IntelliJ, PyCharm, GoLand, etc.) mediante un plugin separado, pero esta guía se centra exclusivamente en la integración con VS Code.

Verificando la Instalación

Una vez instalada, deberías ver dos cambios inmediatos en tu entorno de VS Code:

Haz clic en el icono de Continue en la Barra de Actividades para abrir el panel lateral. En el primer inicio, Continue presentará un flujo de incorporación que te solicitará conectar un proveedor. Puedes omitir o cerrar esto — conectaremos Ollama manualmente en el siguiente paso editando directamente config.json, lo que nos otorga un control mucho mayor que el asistente gráfico.

Comprendiendo la Arquitectura de la Extensión

Antes de avanzar, vale la pena entender qué instala realmente Continue y cómo se comunica:

VS Code Extension (Continue.dev)
        │
        ▼
  config.json  ──────────────────────────────────────────────────┐
        │                                                          │
        ▼                                                          ▼
  Chat Provider (LLM)                               Autocomplete Provider (LLM)
  e.g., Ollama → llama3                             e.g., Ollama → starcoder2
        │                                                          │
        └────────────────────────┬─────────────────────────────────┘
                                 │
                                 ▼
                    http://localhost:11434  (Ollama REST API)

Continue separa el chat y el autocompletado en dos proveedores configurables de forma independiente. Esta es una distinción poderosa — puedes ejecutar un modelo grande ajustado para instrucciones como llama3 o deepseek-coder para consultas conversacionales, mientras usas un modelo liviano de fill-in-the-middle como starcoder2:3b para completados en línea de baja latencia. Ninguna otra alternativa mainstream a Copilot expone este nivel de granularidad de proveedor.

Localizando el Archivo config.json

El comportamiento completo de Continue está controlado por un único archivo JSON. Conoce dónde reside:

Puedes abrirlo directamente desde VS Code usando el icono de engranaje de configuración del panel de Continue, o navegar hasta él manualmente en tu terminal:

# macOS / Linux
cat ~/.continue/config.json

# Windows (PowerShell)
Get-Content "$env:USERPROFILE\.continue\config.json"

Con la extensión instalada y el archivo de configuración localizado, estás listo para apuntar Continue a tu instancia local de Ollama.

Step 4 Paso 2: Configurando config.json para Ollama

Una vez que Continue.dev está instalado, el comportamiento completo de la extensión está gobernado por un único archivo: config.json. Aquí es donde conectas Continue a tu instancia local de Ollama, defines qué modelos gestionan el chat versus el autocompletado, y ajustas los parámetros de rendimiento. Hacer bien este archivo es la diferencia entre una configuración lenta e inestable y una que rivaliza con GitHub Copilot en capacidad de respuesta.

Localizando config.json

Continue almacena su configuración en tu directorio de inicio:

También puedes abrirlo directamente desde VS Code usando la barra lateral de Continue — haz clic en el icono de engranaje en la parte inferior del panel de Continue, y abrirá config.json en el editor.

La Configuración Mínima de Ollama

A continuación se muestra un config.json base listo para producción que conecta Continue a una instancia de Ollama ejecutándose localmente, tanto para chat como para autocompletado con Tab:

{
  "models": [
    {
      "title": "CodeLlama 13B (Chat)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (Autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85
  },
  "allowAnonymousTelemetry": false
}

¿Por qué dos modelos separados? Los modelos de chat están optimizados para seguir instrucciones y mantener diálogos de múltiples turnos. Los modelos de autocompletado — particularmente aquellos entrenados con Fill-in-the-Middle (FIM) — están específicamente ajustados para predecir código dado un contexto de prefijo y sufijo. Mezclar ambos degrada las dos experiencias.

Desglose de Cada Campo

Array models — Define los modelos disponibles en el panel de chat de Continue. Puedes agregar múltiples entradas y alternar entre ellas en tiempo de ejecución. Cada objeto requiere: - provider: establecido en "ollama" para inferencia local - model: la etiqueta exacta tal como aparece en ollama list - apiBase: el endpoint REST predeterminado de Ollama; solo cámbialo si has reasignado el puerto

tabAutocompleteModel — Una entrada dedicada para el autocompletado en línea. Este modelo se activa en cada pausa de pulsación de tecla, por lo que más pequeño y rápido es mejor aquí. Un modelo de 3B–7B parámetros con soporte FIM es el punto óptimo.

tabAutocompleteOptions — Control detallado sobre el motor de autocompletado:

allowAnonymousTelemetry — Establece esto en false. Estás ejecutando IA local específicamente para mantener tu código fuera de servidores de terceros; no hay razón para enviar telemetría al pipeline de análisis de Continue.

Verificando la Conexión

Después de guardar config.json, confirma que Ollama es accesible desde Continue abriendo la Paleta de Comandos de VS Code (Cmd+Shift+P / Ctrl+Shift+P) y ejecutando:

Continue: Open Debug Panel

Deberías ver un indicador de estado verde y un ping exitoso al modelo. Si encuentras un error de conexión rechazada, verifica que Ollama esté en ejecución con:

ollama serve
# or check its status
curl http://localhost:11434/api/tags

Una respuesta JSON válida listando tus modelos descargados confirma que la API está activa y Continue puede proceder a servir completados.

Step 5 Paso 3: Descargando Code Llama o StarCoder2

Con Continue.dev instalado y tu config.json configurado, la siguiente decisión crítica es qué modelo descargas realmente a tu máquina. Para el autocompletado de código local y el chat, dos modelos dominan la conversación: Code Llama (Meta) y StarCoder2 (BigCode/Hugging Face). Ambos funcionan excelentemente a través de Ollama, pero tienen fortalezas significativamente distintas. Vamos a desglosarlos y luego recorrer los comandos exactos de descarga.

Comparativa de Modelos de un Vistazo

Recomendación: Si tienes 8 GB de VRAM o RAM disponibles, comienza con codellama:7b-code para una experiencia equilibrada. Si estás enfocado puramente en la calidad del autocompletado en línea y el soporte multilenguaje, starcoder2:7b frecuentemente le supera en los benchmarks de fill-in-the-middle (FIM).

Descargando Code Llama mediante Ollama

Ollama hace la gestión de modelos trivialmente sencilla. Abre tu terminal y ejecuta:

# Lightweight 7B instruct variant — best starting point
ollama pull codellama:7b-instruct

# 7B code-specialized variant — better raw completion, less chat
ollama pull codellama:7b-code

# If you have the hardware headroom (13B is noticeably sharper)
ollama pull codellama:13b-instruct

La variante instruct comprende instrucciones en lenguaje natural y es ideal para el panel de chat dentro de Continue.dev. La variante code está simplificada y ajustada puramente para tareas de completado — considérala como la variante "motor de autocompletado".

Después de la descarga, verifica que el modelo está disponible:

ollama list

Deberías ver una salida similar a:

NAME                    ID              SIZE    MODIFIED
codellama:7b-instruct   8fdf8f752f6e    3.8 GB  2 minutes ago

Descargando StarCoder2 mediante Ollama

StarCoder2 fue construido específicamente para tareas de fill-in-the-middle (FIM) — exactamente aquello en lo que se basa el autocompletado de IDE. Fue entrenado en más de 600 lenguajes de programación del conjunto de datos The Stack v2, lo que lo hace excepcionalmente amplio.

# 3B — runs on nearly any modern machine, including CPU-only
ollama pull starcoder2:3b

# 7B — sweet spot for quality vs. resource usage
ollama pull starcoder2:7b

# 15B — requires ~10+ GB VRAM, but delivers near-Copilot quality
ollama pull starcoder2:15b

Prueba el modelo inmediatamente desde tu terminal para confirmar que responde correctamente:

ollama run starcoder2:7b "Write a Python function to flatten a nested list."

Si obtienes una salida coherente y sintácticamente correcta, tu modelo está listo para que Continue.dev lo consuma.

Una Nota sobre las Limitaciones de Hardware

No te dejes intimidar por los recuentos de parámetros más grandes. Los modelos cuantizados (que Ollama descarga por defecto — típicamente con cuantización Q4_K_M) son dramáticamente más pequeños que sus tamaños teóricos. Un modelo de 7B en cuantización Q4 se ejecuta cómodamente en:

• Macs con Apple Silicon (M1/M2/M3) con 16 GB de memoria unificada — aceleración GPU casi nativa mediante Metal
• GPUs NVIDIA con 6–8 GB de VRAM (RTX 3060, 4060, etc.)
• Máquinas solo-CPU con 16+ GB de RAM — más lento, pero totalmente funcional para chat; la latencia del autocompletado será perceptible

Si estás limitado a CPU, prefiere firmemente starcoder2:3b o codellama:7b-code — su menor huella de memoria se traduce directamente en generación de tokens más rápida y una experiencia de autocompletado más responsiva.

Una vez que tu modelo elegido esté descargado y verificado, Continue.dev lo descubrirá automáticamente a través del endpoint de API de Ollama (http://localhost:11434) que configuraste en el Paso 2 — no se requiere ningún enlace adicional.

Step 6 Mejores Prácticas para el Autocompletado y Chat Local

Poner en marcha el stack es solo la mitad de la batalla. Extraer la máxima productividad de una configuración de IA local requiere decisiones de configuración deliberadas, hábitos disciplinados en los prompts y una comprensión clara de dónde los modelos locales sobresalen versus dónde te frustrarán.

Estrategia de Selección de Modelos

No todos los modelos son iguales, y la herramienta correcta depende de la tarea en cuestión. Ejecuta modelos separados para autocompletado y chat en lugar de forzar a un único modelo a hacer ambas cosas.

La idea clave: el autocompletado es sensible a la latencia, el chat es sensible a la calidad. Un modelo de 3B respondiendo en 150ms se siente mágico para completados. Ese mismo modelo dando una respuesta superficial a una pregunta arquitectónica compleja se siente roto.

Ajustando el Comportamiento del Autocompletado en config.json

La configuración de autocompletado predeterminada en Continue.dev es conservadora. Ajústala para una mejor experiencia:

{
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85,
    "multilineCompletions": "always",
    "debounceDelay": 300
  }
}

Opciones clave explicadas:

• debounceDelay: 300 — Espera 300ms después de tu última pulsación de tecla antes de disparar una solicitud de completado. Los valores más bajos se sienten más responsivos pero sobrecargan tu GPU. Encuentra tu umbral.
• prefixPercentage: 0.85 — Asigna el 85% de la ventana de contexto al código antes del cursor. Esto es ideal dado que el modelo necesita el máximo contexto de prefijo para producir completados relevantes.
• multilineCompletions: "always" — Obliga al modelo a intentar completar bloques enteros, no solo líneas individuales. Esencial para la generación de boilerplate.
• maxPromptTokens: 1024 — Mantiene las solicitudes ligeras. Los valores más grandes mejoran la calidad marginalmente pero aumentan la latencia de forma significativa en hardware de consumo.

Gestión de Contexto para el Chat

La interfaz de chat es donde la mayoría de los desarrolladores subutilizan Continue.dev. Usa los proveedores de contexto integrados de forma agresiva:

• @file — Referencia un archivo específico directamente en tu prompt
• @codebase — Activa una búsqueda por embeddings en todo tu repositorio (requiere configurar un modelo de embeddings)
• @terminal — Pega la salida más reciente de tu terminal en el contexto
• @problems — Inyecta el contenido del panel de Problemas de VS Code, perfecto para depurar errores del compilador

Flujo de trabajo de ejemplo para depuración:

@problems @file src/auth/middleware.ts

The JWT validation is throwing a 401 on every request even with a valid token.
Walk me through what could cause this and show me the fix.

Este único prompt le proporciona al modelo el mensaje de error, el archivo fuente relevante y un enunciado claro del problema — mejorando drásticamente la calidad del resultado.

Consejos de Optimización de Hardware

Usuarios de GPU (NVIDIA/AMD): Asegúrate de que Ollama esté usando realmente tu GPU y no retrocediendo a CPU:

# Verify GPU utilization while a model is loaded
ollama ps

# Check VRAM usage
nvidia-smi  # NVIDIA
rocm-smi    # AMD

Si ollama ps muestra 100% CPU, probablemente tengas un problema de desbordamiento de VRAM. Cambia a una cuantización más pequeña:

# Pull a smaller quantized variant
ollama pull codellama:13b-code-q4_K_M

Usuarios solo-CPU: Mant

Continue Reading

Performance

Mistral 7B vs Llama 3 on Apple Silicon

Tools

Best GUI clients for Local LLMs

Advanced

Quantization 101: Speed up your Inference