# Come potenziare Claude Code con Modelli Locali (Ollama) e Cloud Economici (Z.AI): Guida 2026

> Fonte: https://francescogruner.it/claude-code-ollama-glm-guida-2026/

La notizia non è “Claude Code gratis”.

 

La notizia vera è questa:

 

Ollama ora è compatibile con l’Anthropic Messages API.

 

Tradotto:

 

→ Claude Code può parlare con Ollama come endpoint Anthropic-compatible  
→ puoi usare modelli open-source in locale *con lo stesso harness di Claude Code*  
→ ma la qualità finale dipende dal modello e dall’hardware

 

In parallelo:

 

→ GLM-4.7 (Z.AI) si poteva già usare allo stesso modo  
→ ed è spesso la scelta più sensata se vuoi produttività e costi bassi

   

Indice dei contenuti

 [Toggle](#) 

- [Claude Code con Ollama: guida rapida](#Claude_Code_con_Ollama_guida_rapida)

- [Cosa NON cambia](#Cosa_NON_cambia)
- [Ti sta piacendo?](#Ti_sta_piacendo)

- [La novità è la compatibilità API](#La_novita_e_la_compatibilita_API)
- [Cosa fa Claude Code nel concreto](#Cosa_fa_Claude_Code_nel_concreto)
- [Tabella comparativa (costo, privacy, performance)](#Tabella_comparativa_costo_privacy_performance)
- [Parte 1: Claude Code + Ollama (modelli locali)](#Parte_1_Claude_Code_Ollama_modelli_locali)

- [Quando conviene davvero](#Quando_conviene_davvero)
- [Requisiti hardware (reali)](#Requisiti_hardware_reali)
- [Step 1: installare Claude Code](#Step_1_installare_Claude_Code)
- [Step 2: collegare Claude Code a Ollama](#Step_2_collegare_Claude_Code_a_Ollama)
- [Step 3: avviare Claude Code con un modell](#Step_3_avviare_Claude_Code_con_un_modell)
- [Modelli consigliati su Ollama (per coding)](#Modelli_consigliati_su_Ollama_per_coding)
- [Ollama Cloud (se non vuoi hardware)](#Ollama_Cloud_se_non_vuoi_hardware)
- [Parte 2: Claude Code + GLM-4.7 (Z.AI)](#Parte_2_Claude_Code_GLM-47_ZAI)
- [Claude Code con GLM-4.7: alternativa economica ad Anthropic](#Claude_Code_con_GLM-47_alternativa_economica_ad_Anthropic)
- [Piani Z.AI (GLM Coding Plan)](#Piani_ZAI_GLM_Coding_Plan)
- [Configurazione GLM-4.7 in Claude Code (3 metodi)](#Configurazione_GLM-47_in_Claude_Code_3_metodi)

- [Metodo 1: Automated Coding Tool Helper (consigliato)](#Metodo_1_Automated_Coding_Tool_Helper_consigliato)
- [Metodo 2: Manual configuration (Windows PowerShell)](#Metodo_2_Manual_configuration_Windows_PowerShell)
- [Mapping modelli in Claude Code (settings.json)](#Mapping_modelli_in_Claude_Code_settingsjson)
- [Strategia consigliata (quella che funziona davvero)](#Strategia_consigliata_quella_che_funziona_davvero)
- [Troubleshooting (problemi frequenti)](#Troubleshooting_problemi_frequenti)

- [Le variabili ambiente non fanno effetto](#Le_variabili_ambiente_non_fanno_effetto)
- [Ho modificato settings.json ma non cambia nulla](#Ho_modificato_settingsjson_ma_non_cambia_nulla)
- [In locale è troppo lento](#In_locale_e_troppo_lento)
- [FAQ](#FAQ)

- [Claude Code è open source?](#Claude_Code_e_open_source)
- [Quindi perché lo chiamano “gratis”?](#Quindi_perche_lo_chiamano_%E2%80%9Cgratis%E2%80%9D)
- [Si poteva già usare GLM-4.7 prima?](#Si_poteva_gia_usare_GLM-47_prima)
- [Ha senso usare Ollama per sostituire Opus?](#Ha_senso_usare_Ollama_per_sostituire_Opus)
- [Link ufficiali](#Link_ufficiali)
- [Conclusione](#Conclusione)

 

## Claude Code con Ollama: guida rapida

 

Ne avevo già parlato e mostrato in pratica anche in un video qualche tempo fa:

    

### Cosa NON cambia

 

Claude Code non è diventato magicamente “gratis” nel senso del modello.

 

Perché:

 

→ Claude Code è l’interfaccia (tool)  
→ Claude (Opus/Sonnet) sono i modelli (motore)

 

Quindi “free” ha senso solo se intendi:

 

→ uso dell’interfaccia senza pagare token cloud  
→ ma pagando prestazioni con hardware locale

 

Inoltre, anche prima era già possibile usare provider alternativi tramite endpoint compatibili (es. GLM con Z.AI).

                  

## Ti sta piacendo?

 

Ricevi una guida pratica ogni settimana. AI, tool e automazioni.

            Iscriviti gratis             Perfetto, sei dentro.         

### La novità è la compatibilità API

 

La novità vera è l’adozione e lo standard.

 

Ollama ora:

 

→ espone ufficialmente un endpoint Anthropic-compatible  
→ rende banale collegare Claude Code a modelli locali  
→ abbassa la barriera d’ingresso per chi non voleva “hack” o proxy strani

 

Non nasce una possibilità nuova.

 

Diventa mainstream una possibilità che esisteva già, ma era meno accessibile.

 

## Cosa fa Claude Code nel concreto

 

Claude Code non è solo “chat nel terminale”.

 

È un agente che lavora su:

 

→ file system  
→ comandi di shell  
→ workflow di sviluppo  
→ git  
→ operazioni ripetitive e task multi-step

 

E il suo valore è che puoi usare lo stesso workflow cambiando motore.

 

Claude Code è la scocca.  
Il modello è il motore.

 

## Tabella comparativa (costo, privacy, performance)

 CaratteristicaClaude (Anthropic)Ollama (Local)Z.AI (GLM-4.7)Costoalto (token/abbonamento)quasi zero (HW + corrente)basso (piani Lite/Pro)Privacycloud100% localecloudQualità codingmassimamedia/variabilealtaVelocitàaltaspesso lentaalta e stabileSetupimmediatomediorapidoIdeale perrefactor pesantiroutine + privacycoding quotidiano 

## Parte 1: Claude Code + Ollama (modelli locali)

 

### Quando conviene davvero

 

Claude Code con Ollama ha senso per:

 

→ dati sensibili e repo privati  
→ task brevi, ripetitivi, ben delimitati  
→ scaffolding di codice  
→ spiegazioni e documentazione  
→ generazione test su componenti singoli

 

Dove invece spesso delude:

 

→ refactor multi-file  
→ agentic loop lunghi  
→ contesti enormi  
→ progetti complessi con tante dipendenze

 

Perché?  
Perché in locale la potenza non è “gratis”: la paghi in RAM/VRAM e latenza.

 

### Requisiti hardware (reali)

 

Se vuoi un’esperienza decente su task agentici:

 

→ almeno 32 GB di RAM (meglio unificata su Mac)  
oppure  
→ 12-16 GB di VRAM dedicata su NVIDIA

 

Sotto questi valori, con modelli “coder” medio-grandi:

 

→ swap  
→ lentezza  
→ contesto instabile  
→ loop frustranti

 

In pratica: funziona, ma non aspettarti Opus su un laptop medio.

 

### Step 1: installare Claude Code

 

**macOS / Linux / WSL**

 

```
curl -fsSL https://claude.ai/install.sh | bash
```

 

**Windows PowerShell**

 

```
irm https://claude.ai/install.ps1 | iex
```

 

### Step 2: collegare Claude Code a Ollama

 

**macOS / Linux / WSL**

 

```
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_BASE_URL=http://localhost:11434
```

 

**Windows PowerShell**

 

```
setx ANTHROPIC_AUTH_TOKEN "ollama"
setx ANTHROPIC_BASE_URL "http://localhost:11434"
```

 

Nota: su Windows devi aprire un nuovo terminale dopo `setx`.

 

### Step 3: avviare Claude Code con un modell

 

Esempio:

 

```
claude --model qwen3-coder
```

 

Oppure:

 

```
claude --model gpt-oss:20b
```

 

### Modelli consigliati su Ollama (per coding)

 

Per i casi d’uso Claude Code, i più sensati sono:

 

→ gpt-oss:20b  
→ qwen3-coder

 

Nota pratica:  
conviene usare modelli con contesto ampio (64k e oltre) se vuoi lavorare su repo più grandi.

 

### Ollama Cloud (se non vuoi hardware)

 

Ollama oggi non è solo “local”.

 

Puoi collegare Claude Code anche a modelli cloud tramite Ollama.

 

Questo è utile se vuoi:

 

→ stessa interfaccia  
→ performance più prevedibili  
→ senza gestire GPU e RAM in casa

 

## Parte 2: Claude Code + GLM-4.7 (Z.AI)

 

Qui arriviamo alla parte più interessante.

 

Perché tanti vogliono Claude Code per lavorare seriamente.

 

Ma non vogliono:

 

→ pagare sempre modelli premium  
→ bruciarsi budget token inutilmente  
→ o aspettare 30 secondi per una risposta locale lenta

 

Ed è qui che GLM-4.7 diventa una scelta intelligente.

 

## Claude Code con GLM-4.7: alternativa economica ad Anthropic

 

GLM-4.7 è interessante perché:

 

→ qualità alta nel coding quotidiano  
→ costo molto più basso rispetto ai top premium  
→ cloud stabile e veloce  
→ compatibile via endpoint Anthropic-compatible

 

Il punto non è “battere Opus”.

 

Il punto è:

 

→ far funzionare bene Claude Code in produzione  
→ senza far piangere il budget

 

## Piani Z.AI (GLM Coding Plan)

 

Z.AI propone diversi piani, ma in sintesi:

 

**Lite (mensile)**  
$3 primo mese, poi $6/mese  
→ circa 3× usage rispetto a un piano tipo Claude Pro  
→ workload leggeri/medi  
→ GLM-4.7

 

**Lite (annuale)**  
$28.8 primo anno, poi $72/anno  
→ ideale se vuoi risparmio costante

 

**Pro (annuale)**  
$144 primo anno, poi $360/anno  
→ 5× Lite  
→ 40-60% più veloce  
→ tool extra + MCP inclusi

 

## Configurazione GLM-4.7 in Claude Code (3 metodi)

 

Z.AI descrive 3 approcci:

 

Automated Coding Tool Helper  
Automated Script  
Manual configuration

 

La scelta migliore dipende da quanto vuoi controllo.

 

### Metodo 1: Automated Coding Tool Helper (consigliato)

 

È il modo più rapido:

 

```
npx @z_ai/coding-helper
```

 

Segui la procedura guidata e lui:

 

→ configura tutto  
→ collega Claude Code  
→ gestisce piani e MCP

 

### Metodo 2: Manual configuration (Windows PowerShell)

 

Se vuoi fare tutto a mano (utile anche per capire cosa succede):

 

```
[System.Environment]::SetEnvironmentVariable('ANTHROPIC_AUTH_TOKEN', 'your_zai_api_key', 'User')
[System.Environment]::SetEnvironmentVariable('ANTHROPIC_BASE_URL', 'https://api.z.ai/api/anthropic', 'User')
```

 

Poi apri un nuovo terminale e avvia:

 

```
claude
```

 

### Mapping modelli in Claude Code (settings.json)

 

Questa parte è fondamentale per avere un workflow pulito.

 

Z.AI usa una mappatura interna:

 

→ Claude Code “vede” Opus/Sonnet/Haiku  
→ sotto ci sono modelli GLM reali

 

Puoi controllare o modificare il mapping in:

 

`~/.claude/settings.json`

 

Esempio:

 

```
{
  "env": {
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.7",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.7"
  }
}
```

 

Poi riavvia Claude Code e verifica con:

 

```
/status
```

 

Nota:  
di solito è meglio non hardcodare troppo, perché quando Z.AI aggiorna i default potresti perdere upgrade automatici.

 

## Strategia consigliata (quella che funziona davvero)

 

Il setup migliore oggi non è “local vs cloud”.

 

È un modello ibrido.

 

**Local (Ollama)**  
→ routine  
→ privacy  
→ task piccoli  
→ costo token zero

 

**Cloud economico (GLM-4.7 / Z.AI)**  
→ coding quotidiano serio  
→ debugging e sviluppo reale  
→ costi molto più bassi rispetto ai premium

 

**Premium (Opus/Sonnet)**  
→ refactor grossi  
→ ragionamento lungo  
→ affidabilità massima

 

Il punto non è risparmiare sempre.

 

Il punto è spendere bene.

 

## Troubleshooting (problemi frequenti)

 

### Le variabili ambiente non fanno effetto

 

→ chiudi e riapri il terminale  
→ su Windows è obbligatorio

 

### Ho modificato settings.json ma non cambia nulla

 

→ chiudi Claude Code  
→ riapri una nuova finestra terminale  
→ controlla che il JSON sia valido  
→ prova a cancellare `~/.claude/settings.json` e ripartire

 

### In locale è troppo lento

 

Probabile causa:  
→ modello troppo grande per RAM/VRAM  
Soluzione:  
→ usa un modello più piccolo  
→ oppure passa a GLM-4.7 cloud quando vuoi produttività

 

## FAQ

 

### Claude Code è open source?

 

No, è proprietario.

 

### Quindi perché lo chiamano “gratis”?

 

Perché puoi usarlo senza pagare token cloud, se usi modelli locali.  
Ma “gratis” significa solo: costi token = zero.  
Il costo si sposta su hardware e tempo.

 

### Si poteva già usare GLM-4.7 prima?

 

Sì.  
La novità è che ora Ollama è ufficialmente compatibile, quindi la stessa logica diventa più comune e facile da usare.

 

### Ha senso usare Ollama per sostituire Opus?

 

No, non su hardware standard.  
Ollama è ottimo per privacy e routine, ma la qualità e la velocità di Opus/Sonnet restano superiori.

 

## Link ufficiali

 

Ollama blog (Claude Code compatibility):  
[https://ollama.com/blog/claude](https://ollama.com/blog/claude?utm_source=chatgpt.com)

 

Z.AI Claude Code guide (GLM Coding Plan):  
[https://docs.z.ai/devpack/tool/claude](https://docs.z.ai/devpack/tool/claude?utm_source=chatgpt.com)

 

## Conclusione

 

La notizia non è “Claude Code gratis”.

 

La notizia vera è questa:

 

Claude Code sta diventando una piattaforma.  
Lo stesso harness può parlare con più motori.

 

→ locale quando serve privacy  
→ cloud economico quando serve produttività  
→ premium quando serve il massimo

 

Non è hype.

 

È finalmente una scelta architetturale sensata per sviluppare meglio e spendere meno.