Sostituire GitHub Copilot: Ollama + Continue.dev

laptop_mac macOS Sonoma Intermediate schedule 8 min read

by Alex Rivera • May 14, 2024

Step 1 Il Costo dell'Autocompletamento Cloud vs. AI Locale

Ogni tasto che premi in VS Code con GitHub Copilot attivo viene trasmesso all'infrastruttura OpenAI ospitata su Azure di Microsoft. Non si tratta di una teoria del complotto — è l'architettura documentata del prodotto. I tuoi algoritmi proprietari, la logica di business interna, le funzionalità non ancora rilasciate e le decisioni architetturali stanno tutte lasciando la tua macchina. Per gli sviluppatori individuali che lavorano su progetti personali, questo compromesso è spesso accettabile. Per i team che sviluppano software commercialmente sensibile, si tratta di un rischio materiale in termini di sicurezza e conformità.

C'è poi la dimensione finanziaria.

La Realtà dei Prezzi di GitHub Copilot

Per un'organizzazione ingegneristica di medie dimensioni composta da 50 sviluppatori sul piano Business, si parla di $11.400 all'anno — pagati a tempo indeterminato a un fornitore esterno, senza alcuna proprietà del modello sottostante né garanzia di stabilità dei prezzi. Microsoft ha già rivisto i prezzi di Copilot al rialzo dal lancio, e non vi è alcuna ragione strutturale per aspettarsi un'inversione di tale tendenza.

Cosa Significa Effettivamente "AI Locale"

Eseguire un modello locale tramite Ollama cambia l'equazione radicalmente. Il costo computazionale è l'hardware già in tuo possesso. Il modello di privacy è assoluto — nessun dato lascia la tua macchina. La latenza è spesso inferiore rispetto al completamento cloud, poiché si elimina l'overhead di rete del round-trip verso i server di inferenza remoti.

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

Flusso Ollama locale:
Keypress → VS Code → localhost:11434 → Inference → Response → VS Code

Il percorso di inferenza su localhost rimuove un'intera categoria di modalità di guasto: interruzioni delle API, rate limiting, interferenze dei proxy aziendali e varianza di latenza geografica. Gli sviluppatori dietro firewall aziendali rigidi, che in precedenza non potevano usare Copilot, possono ora eseguire un modello di codice pienamente capace senza toccare il perimetro di rete.

I Costi Nascosti della Dipendenza Cloud

Al di là delle licenze, l'autocompletamento cloud introduce un accoppiamento operativo che è facile sottovalutare:

• Vendor lock-in: il flusso di lavoro del tuo team diventa dipendente da un servizio di terze parti con controllo unilaterale su prezzi, disponibilità e termini di servizio.
• Overhead di conformità: molti settori regolamentati (sanità, finanza, difesa) richiedono accordi formali sul trattamento dei dati e revisioni di sicurezza per qualsiasi strumento che trasmetta codice all'esterno. Il processo di approvazione di Copilot non è banale in questi ambienti.
• Perdita del contesto dalla finestra: i modelli cloud ricevono non solo il file corrente, ma anche buffer di contesto circostanti — file adiacenti, schede aperte di recente e metadati del repository a seconda della configurazione.
• Lacune nella traccia di audit: quando i suggerimenti di codice provengono da una scatola nera esterna, attribuire la provenienza della proprietà intellettuale diventa complicato in caso di contenzioso legale o dispute di licenza.

Dove i Modelli Locali Sono Competitivi Oggi

I moderni modelli quantizzati come Code Llama 13B e StarCoder2 7B eseguiti su hardware consumer raggiungono una qualità di completamento genuinamente competitiva con Copilot per gli scenari di autocompletamento più comuni: generazione di boilerplate, completamento di firme di funzioni, scaffolding di test e implementazioni di algoritmi comuni. Il divario si riduce ulteriormente quando il modello opera su codice in linguaggi e pattern per cui è stato specificamente addestrato.

Il calcolo è semplice: zero costo marginale, completa sovranità sui dati e nessuna dipendenza esterna versus una crescente bolletta SaaS e un accordo implicito a condividere il proprio codebase con un provider di inferenza cloud. Per i team seriamente orientati alla proprietà a lungo termine della toolchain, l'approccio local-first non è un compromesso — è la scelta architetturale più difendibile.

Step 2 Prerequisiti: VS Code e Ollama

Prima di addentrarsi nella configurazione, è necessario avere due componenti fondamentali verificati e consolidati. Saltare la corretta validazione dei prerequisiti è la singola causa più comune per cui gli sviluppatori perdono ore a fare debug di quello che dovrebbe essere un setup di AI locale lineare. Eseguili correttamente, e tutto il resto diventa meccanico.

Visual Studio Code

Hai bisogno di VS Code 1.80 o successivo. L'estensione Continue.dev dipende dalle API moderne di VS Code per i completamenti inline ghost-text, e le versioni precedenti falliranno silenziosamente o produrranno un comportamento degradato.

Verifica la tua versione dalla riga di comando:

code --version

Output atteso (il tuo potrebbe essere più recente):

1.89.1
e170252f762678dec6ca2cc69aba1864a9a1f8ad
x64

Se stai usando un fork come VSCodium, Continue.dev è completamente compatibile — assicurati solo di scaricare l'estensione dall'Open VSX Registry anziché dal Microsoft Marketplace, poiché VSCodium non include l'host di estensioni proprietario di Microsoft per impostazione predefinita.

Ollama

Ollama è il runtime locale per modelli che gestisce i download dei modelli, la gestione della quantizzazione ed espone un'API REST compatibile con OpenAI su localhost:11434. Questa compatibilità è esattamente il motivo per cui Continue.dev si integra con esso in modo così pulito — non è richiesta alcuna architettura di plugin personalizzata.

Installazione per piattaforma:

Dopo l'installazione, avvia il daemon di Ollama:

ollama serve

Su macOS, Ollama viene eseguito automaticamente come applicazione nella barra dei menu dopo l'installazione. Su Linux, potresti volerlo come servizio systemd:

sudo systemctl enable ollama
sudo systemctl start ollama

Verifica che l'API sia attiva:

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

Una risposta corretta restituisce un oggetto JSON che elenca i modelli installati localmente. Una lista vuota va bene in questa fase — il download dei modelli avviene in un passaggio successivo.

{
  "models": []
}

Considerazioni sull'Hardware

Questo è il punto in cui la maggior parte dei tutorial ti lascia senza risposta. Il tuo hardware determina direttamente quali modelli sono praticabili e a quale livello di quantizzazione.

Ollama scarica automaticamente i layer sulla tua GPU tramite Metal (Apple Silicon), CUDA (NVIDIA) o ROCm (AMD). Non è richiesta alcuna configurazione manuale — Ollama rileva il tuo hardware e ottimizza l'offloading dei layer in modo trasparente.

Nota critica per gli utenti Apple Silicon: La memoria unificata è condivisa tra CPU e GPU. Un MacBook Pro M3 con 16 GB può eseguire un modello 13B comodamente perché non vi è un limite discreto di VRAM. Questo è uno degli argomenti più forti a favore di Apple Silicon nei workflow di AI locale.

Verifica dell'Ambiente

Esegui questo rapido controllo di sanità prima di procedere:

# Conferma la versione di VS Code
code --version

# Conferma che Ollama è in esecuzione e risponde
curl -s http://localhost:11434/api/tags | python3 -m json.tool

# Conferma l'accelerazione GPU (log di Ollama)
ollama run llama3.2:1b "say ok"

Osserva l'output del terminale di Ollama durante l'inferenza del modello. Dovresti vedere i conteggi di offloading dei layer con riferimento alla tua GPU. Se tutto viene eseguito su CPU, revisiona l'installazione dei driver prima di scaricare modelli di codice più grandi.

Con entrambi i prerequisiti confermati, sei pronto per installare Continue.dev e collegare tutto insieme.

Step 3 Step 1: Installazione dell'Estensione Continue.dev

Continue.dev è la pietra angolare di questa intera configurazione — un assistente AI per il codice open-source che funge da sostituto drop-in per GitHub Copilot, ma con una differenza architetturale critica: instrada le tue richieste dove tu gli indichi, inclusa un'istanza Ollama in esecuzione localmente. Nessuna telemetria. Nessun egresso cloud. Nessun abbonamento.

Installazione dal VS Code Marketplace

Il percorso di installazione più semplice passa attraverso il VS Code Extension Marketplace direttamente all'interno dell'editor:

1. Apri VS Code
2. Premi Ctrl+Shift+X (Windows/Linux) o Cmd+Shift+X (macOS) per aprire il pannello delle Estensioni
3. Cerca "Continue"
4. Individua l'estensione pubblicata da Continue (l'icona è un logo a gradiente viola distintivo)
5. Clicca Install

In alternativa, installala dalla riga di comando usando la CLI di VS Code:

code --install-extension Continue.continue

Oppure se stai usando VS Codium (il fork privo di telemetria), l'estensione è disponibile sull'Open VSX Registry:

codium --install-extension Continue.continue

Nota: Continue.dev supporta anche gli IDE JetBrains (IntelliJ, PyCharm, GoLand, ecc.) tramite un plugin separato, ma questa guida si concentra esclusivamente sull'integrazione con VS Code.

Verifica dell'Installazione

Una volta installata, dovresti vedere due cambiamenti immediati nel tuo ambiente VS Code:

Clicca sull'icona Continue nell'Activity Bar per aprire il pannello laterale. Al primo avvio, Continue presenterà un flusso di onboarding che ti invita a connettere un provider. Puoi saltare o ignorare questa parte — collegheremo Ollama manualmente nel passo successivo modificando direttamente config.json, il che ci offre un controllo nettamente superiore rispetto alla procedura guidata della GUI.

Comprensione dell'Architettura dell'Estensione

Prima di procedere, vale la pena capire cosa installa effettivamente Continue e come 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 chat e autocompletamento in due provider configurabili indipendentemente. Questa è una distinzione potente — puoi eseguire un modello grande e instruction-tuned come llama3 o deepseek-coder per le query conversazionali, utilizzando al contempo un modello leggero fill-in-the-middle come starcoder2:3b per i completamenti inline a bassa latenza. Nessun'altra alternativa mainstream a Copilot espone questo livello di granularità dei provider.

Localizzazione del File config.json

L'intero comportamento di Continue è controllato da un singolo file JSON. Sapere dove risiede è fondamentale:

Puoi aprirlo direttamente dall'interno di VS Code usando l'icona a forma di ingranaggio nelle impostazioni del pannello Continue, oppure navigarvi manualmente dal terminale:

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

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

Con l'estensione installata e il file di configurazione localizzato, sei pronto a puntare Continue verso la tua istanza locale di Ollama.

Step 4 Step 2: Configurazione di config.json per Ollama

Una volta installato Continue.dev, l'intero comportamento dell'estensione è governato da un singolo file: config.json. Qui è dove si collega Continue alla tua istanza locale di Ollama, si definisce quali modelli gestiscono la chat rispetto all'autocompletamento, e si regolano i parametri di prestazione. Configurare questo file correttamente è la differenza tra un setup lento e inaffidabile e uno che rivaleggia con GitHub Copilot in termini di reattività.

Localizzazione di config.json

Continue archivia la sua configurazione nella tua directory home:

Puoi anche aprirlo direttamente da VS Code usando la sidebar di Continue — clicca sull'icona a forma di ingranaggio nella parte inferiore del pannello Continue, e si aprirà config.json nell'editor.

La Configurazione Ollama Minimale

Di seguito è riportato un config.json baseline production-ready che connette Continue a un'istanza Ollama in esecuzione locale sia per la chat che per il completamento automatico 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
}

Perché due modelli separati? I modelli di chat sono ottimizzati per il seguimento di istruzioni e il dialogo multi-turno. I modelli di autocompletamento — in particolare quelli addestrati con Fill-in-the-Middle (FIM) — sono specificamente ottimizzati per predire il codice dato un contesto di prefisso e suffisso. Confonderli degrada entrambe le esperienze.

Analisi di Ogni Campo

Array models — Definisce i modelli disponibili nel pannello chat di Continue. Puoi aggiungere più voci e passare dall'una all'altra a runtime. Ogni oggetto richiede: - provider: impostato su "ollama" per l'inferenza locale - model: il tag esatto così come appare in ollama list - apiBase: l'endpoint REST predefinito di Ollama; cambialo solo se hai rimappato la porta

tabAutocompleteModel — Una voce dedicata per l'autocompletamento inline. Questo modello si attiva ad ogni pausa nella digitazione, quindi più piccolo e veloce è meglio. Un modello da 3B a 7B parametri con supporto FIM è il punto di equilibrio ottimale.

tabAutocompleteOptions — Controllo granulare sul motore di autocompletamento:

allowAnonymousTelemetry — Impostalo su false. Stai eseguendo AI locale specificamente per tenere il tuo codice lontano da server di terze parti; non vi è alcun motivo per inviare telemetria alla pipeline di analytics di Continue.

Verifica della Connessione

Dopo aver salvato config.json, conferma che Ollama sia raggiungibile da Continue aprendo il Pannello Comandi di VS Code (Cmd+Shift+P / Ctrl+Shift+P) ed eseguendo:

Continue: Open Debug Panel

Dovresti vedere un indicatore di stato verde e un ping del modello riuscito. Se incontri un errore di connessione rifiutata, verifica che Ollama sia in esecuzione con:

ollama serve
# oppure controlla il suo stato
curl http://localhost:11434/api/tags

Una risposta JSON valida che elenca i modelli scaricati conferma che l'API è attiva e Continue può procedere a servire i completamenti.

Step 5 Step 3: Download di Code Llama o StarCoder2

Con Continue.dev installato e il tuo config.json configurato, la prossima decisione critica è quale modello scaricare effettivamente sulla tua macchina. Per il completamento di codice locale e la chat, due modelli dominano la conversazione: Code Llama (Meta) e StarCoder2 (BigCode/Hugging Face). Entrambi funzionano eccellentemente tramite Ollama, ma hanno punti di forza significativamente diversi. Analizziamoli, quindi esaminiamo i comandi di pull esatti.

Confronto dei Modelli a Colpo d'Occhio

Raccomandazione: Se disponi di 8 GB di VRAM o RAM da dedicare, inizia con codellama:7b-code per un'esperienza equilibrata. Se sei puramente focalizzato sulla qualità dell'autocompletamento inline e il supporto multi-linguaggio, starcoder2:7b spesso lo supera nei benchmark fill-in-the-middle (FIM).

Download di Code Llama tramite Ollama

Ollama rende la gestione dei modelli estremamente semplice. Apri il terminale ed esegui:

# Variante instruct 7B leggera — punto di partenza migliore
ollama pull codellama:7b-instruct

# Variante 7B specializzata nel codice — miglior completamento grezzo, meno chat
ollama pull codellama:7b-code

# Se hai l'headroom hardware (13B è notevolmente più preciso)
ollama pull codellama:13b-instruct

La variante instruct comprende le istruzioni in linguaggio naturale ed è ideale per il pannello chat all'interno di Continue.dev. La variante code è ridotta all'essenziale e ottimizzata puramente per i task di completamento — pensala come la variante "motore di autocompletamento".

Dopo il download, verifica che il modello sia disponibile:

ollama list

Dovresti vedere un output simile a:

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

Download di StarCoder2 tramite Ollama

StarCoder2 è stato costruito appositamente per i task di fill-in-the-middle (FIM) — esattamente ciò su cui si basa l'autocompletamento degli IDE. È stato addestrato su oltre 600 linguaggi di programmazione dal dataset The Stack v2, rendendolo eccezionalmente ampio.

# 3B — funziona su quasi qualsiasi macchina moderna, incluse quelle CPU-only
ollama pull starcoder2:3b

# 7B — punto di equilibrio ideale tra qualità e utilizzo di risorse
ollama pull starcoder2:7b

# 15B — richiede ~10+ GB di VRAM, ma offre qualità vicina a Copilot
ollama pull starcoder2:15b

Testa immediatamente il modello dal terminale per confermare che risponda correttamente:

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

Se ottieni un output coerente e sintatticamente corretto, il tuo modello è pronto per essere consumato da Continue.dev.

Una Nota sui Limiti Hardware

Non lasciare che i conteggi di parametri più elevati ti intimidiscano. I modelli quantizzati (che Ollama scarica per impostazione predefinita — tipicamente con quantizzazione Q4_K_M) sono drasticamente più piccoli rispetto alle loro dimensioni teoriche. Un modello 7B in quantizzazione Q4 funziona comodamente su:

• Mac con Apple Silicon (M1/M2/M3) con 16 GB di memoria unificata — accelerazione GPU quasi nativa tramite Metal
• GPU NVIDIA con 6–8 GB di VRAM (RTX 3060, 4060, ecc.)
• Macchine CPU-only con 16+ GB di RAM — più lento, ma completamente funzionale per la chat; la latenza dell'autocompletamento sarà percepibile

Se sei limitato dalla CPU, preferisci fortemente starcoder2:3b o codellama:7b-code — il loro footprint di memoria inferiore si traduce direttamente in una generazione di token più rapida e un'esperienza di autocompletamento più reattiva.

Una volta scaricato e verificato il modello scelto, Continue.dev lo scoprirà automaticamente tramite l'endpoint API di Ollama (http://localhost:11434) che hai configurato nel Passo 2 — non è richiesto alcun collegamento aggiuntivo.

Step 6 Best Practice per l'Autocompletamento Locale e la Chat

Far funzionare lo stack è solo metà della battaglia. Estrarre la massima produttività da un setup di AI locale richiede scelte di configurazione deliberate, abitudini di prompt disciplinate e una chiara comprensione di dove i modelli locali eccellono rispetto a dove ti frustreranno.

Strategia di Selezione del Modello

Non tutti i modelli sono uguali, e lo strumento giusto dipende dal task in questione. Esegui modelli separati per l'autocompletamento e la chat invece di forzare un singolo modello a fare entrambe le cose.

L'intuizione chiave: l'autocompletamento è sensibile alla latenza, la chat è sensibile alla qualità. Un modello 3B che risponde in 150ms sembra magico per i completamenti. Lo stesso modello che fornisce una risposta superficiale a una domanda architetturale complessa sembra difettoso.

Ottimizzazione del Comportamento dell'Autocompletamento in config.json

Le impostazioni predefinite dell'autocompletamento in Continue.dev sono conservative. Ottimizzale per un'esperienza migliore:

{
  "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
  }
}

Opzioni chiave spiegate:

• debounceDelay: 300 — Attende 300ms dopo l'ultimo tasto premuto prima di inviare una richiesta di completamento. Valori inferiori sembrano più reattivi ma martellano la GPU. Trova la tua soglia.
• prefixPercentage: 0.85 — Alloca l'85% della finestra di contesto al codice prima del cursore. È ideale poiché il modello ha bisogno del massimo contesto di prefisso per produrre completamenti pertinenti.
• multilineCompletions: "always" — Forza il modello a tentare di completare interi blocchi, non solo singole righe. Essenziale per la generazione di boilerplate.
• maxPromptTokens: 1024 — Mantiene le richieste snelle. Valori maggiori migliorano marginalmente la qualità ma aumentano significativamente la latenza sull'hardware consumer.

Gestione del Contesto per la Chat

L'interfaccia chat è il punto in cui la maggior parte degli sviluppatori non sfrutta appieno Continue.dev. Utilizza i provider di contesto integrati in modo aggressivo:

• @file — Referenzia un file specifico direttamente nel tuo prompt
• @codebase — Attiva una ricerca per embeddings sull'intero repository (richiede la configurazione di un modello di embeddings)
• @terminal — Incolla l'output più recente del terminale nel contesto
• @problems — Inserisce il contenuto del pannello Problemi di VS Code, perfetto per il debug degli errori del compilatore

Esempio di workflow per il debug:

@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.

Questo singolo prompt fornisce al modello il messaggio di errore, il file sorgente rilevante e una chiara descrizione del problema — migliorando drasticamente la qualità dell'output.

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