---
title: Comment configurer Gemma 4 avec OpenCode via Ollama (guide 2026)
description: >-
  Exécutez localement Gemma 4 de Google et connectez-le à OpenCode, votre
  assistant de codage en terminal. Guide complet de configuration Ollama +
  OpenCode pour Mac.
date: 2026-04-04T00:00:00.000Z
location: 'San Francisco, CA – 4 avril 2026'
image: /images/gemma-4-ollama-opencode-setup-hero.jpg
keywords: >-
  gemma 4 opencode, ollama gemma 4, modèle local opencode, configuration gemma 4
  ollama, exécuter gemma 4 en local, guide opencode ollama
faq:
  - question: Puis-je utiliser Gemma 4 comme modèle local dans OpenCode ?
    answer: >-
      Oui. Installez Ollama, téléchargez le modèle gemma4, puis ajoutez Ollama
      comme fournisseur personnalisé dans ~/.config/opencode/opencode.jsonc en
      utilisant l'adaptateur @ai-sdk/openai-compatible avec le paramètre baseURL
      défini sur http://localhost:11434/v1.. Utilisez /models dans OpenCode pour
      basculer vers ce modèle.
  - question: De combien de RAM Gemma 4 a-t-il besoin pour fonctionner avec OpenCode ?
    answer: >-
      Le modèle Gemma 4 8B par défaut utilise environ 9,6 Go une fois chargé via
      Ollama. Un Mac doté de 16 Go de mémoire unifiée le fait tourner
      confortablement aux côtés d'OpenCode. La variante 26B requiert 24 Go ou
      plus et n'est pas recommandée pour la plupart des machines grand public.
  - question: Gemma 4 est-il assez rapide pour le codage interactif dans OpenCode ?
    answer: >-
      Sur Apple Silicon avec Ollama v0.19+, Gemma 4 8B fonctionne à des vitesses
      utilisables grâce au backend MLX. Il gère bien les complétions de code,
      les explications et les modifications simples. Pour les tâches complexes
      qui exigent un raisonnement de pointe, ajoutez Haimaker comme second
      fournisseur pour accéder aux modèles cloud.
locale: fr-fr
translationKey: gemma-4-ollama-opencode-setup
---
OpenCode est un assistant de codage en ligne de commande qui communique avec n'importe quelle API compatible OpenAI. Connectez-le à une instance Ollama locale qui exécute Gemma 4 et vous obtenez un assistant de codage gratuit qui n'envoie jamais votre code ailleurs.

Voici comment le configurer sur un Mac doté d'Apple Silicon : installez Ollama, téléchargez Gemma 4, puis reliez-le à OpenCode.

## Prérequis

- Mac doté d'Apple Silicon (M1/M2/M3/M4/M5) et d'au moins 16 Go de mémoire unifiée
- macOS avec Homebrew installé
- OpenCode installé (voir [opencode.ai](https://opencode.ai) ou installez-le via votre gestionnaire de paquets)

Le modèle 8B par défaut de Gemma 4 utilise environ 9,6 Go une fois chargé, donc 16 Go de mémoire unifiée laissent assez de marge pour exécuter à la fois Ollama et OpenCode sans problème.

## Étape 1 : Installer Ollama

```bash
brew install --cask ollama-app
```

Cette commande installe `Ollama.app` dans `/Applications/` et le CLI `ollama` dans `/opt/homebrew/bin/ollama`.

## Étape 2 : Démarrer Ollama

```bash
open -a Ollama
```

Attendez que l'icône apparaisse dans la barre des menus, puis vérifiez que le serveur fonctionne :

```bash
ollama list
```

## Étape 3 : Télécharger Gemma 4

```bash
ollama pull gemma4
```

Le téléchargement pèse environ 9,6 Go. Vérifiez :

```bash
ollama list
# NAME             ID              SIZE      MODIFIED
# gemma4:latest    ...             9.6 GB    ...
```

Testez-le :

```bash
ollama run gemma4:latest "Hello, what model are you?"
```

Vérifiez l'accélération GPU :

```bash
ollama ps
# Should show CPU/GPU split, e.g. 14%/86% CPU/GPU
```

Ollama v0.19+ sur Apple Silicon utilise automatiquement le framework MLX d'Apple pour une inférence plus rapide.

## Étape 4 : Configurer OpenCode pour utiliser Gemma 4

OpenCode utilise un fichier de configuration situé dans `~/.config/opencode/opencode.jsonc`. Ajoutez-y Ollama comme fournisseur personnalisé :

```jsonc
{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:latest": {}
      }
    }
  }
}
```

Puisqu'Ollama fonctionne en local, vous n'avez pas besoin de clé API. OpenCode attend toutefois une entrée d'authentification ; ajoutez donc une valeur factice dans le fichier `~/.local/share/opencode/auth.json` :

```json
{
  "ollama": {
    "type": "api",
    "key": "ollama"
  }
}
```

Redémarrez OpenCode, puis utilisez `/models` pour basculer sur `ollama/gemma4:latest`.

## Étape 5 : Maintenir Gemma 4 chargé en mémoire

Par défaut, Ollama décharge les modèles après 5 minutes d'inactivité. Pour un assistant de codage que vous utilisez tout au long de la journée, cela provoque des démarrages à froid inutiles.

Réglez la durée de maintien en mémoire (keep-alive) sur une valeur illimitée :

```bash
launchctl setenv OLLAMA_KEEP_ALIVE "-1"
```

Redémarrez Ollama pour que la modification prenne effet. Pour que le réglage persiste après un redémarrage, ajoutez cette ligne dans le fichier `~/.zshrc` :

```bash
export OLLAMA_KEEP_ALIVE="-1"
```

Activez le lancement à l'ouverture de session : cliquez sur l'icône Ollama dans la barre des menus → **Lancer à l'ouverture de session** (Launch at Login).

#### Préchargement automatique au démarrage

Créez un agent de lancement pour que Gemma 4 soit chargé et prêt après chaque redémarrage :

```bash
cat << 'EOF' > ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.ollama.preload-gemma4</string>
    <key>ProgramArguments</key>
    <array>
        <string>/opt/homebrew/bin/ollama</string>
        <string>run</string>
        <string>gemma4:latest</string>
        <string></string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>StartInterval</key>
    <integer>300</integer>
    <key>StandardOutPath</key>
    <string>/tmp/ollama-preload.log</string>
    <key>StandardErrorPath</key>
    <string>/tmp/ollama-preload.log</string>
</dict>
</plist>
EOF

launchctl load ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
```

Une requête vide est envoyée au modèle toutes les 5 minutes pour le maintenir en mémoire.

## Ce qui fonctionne bien avec Gemma 4 dans OpenCode

Gemma 4 8B est gratuit, s'exécute en local et se révèle étonnamment utile pour le travail de codage quotidien :

- **Explications de code.** Demandez-lui ce que fait une fonction, comment un module est organisé, ou à quoi correspond une regex. Les réponses sont claires et généralement correctes sur des bases de code courantes.
- **Modifications rapides.** Corriger une coquille, mettre à jour un import, ajouter un champ à une définition de type, renommer une variable. Les modifications sur un seul fichier sont son point fort.
- **Génération de boilerplate.** Fichiers de configuration, stubs de tests, scaffolding de routes API, modèles de Dockerfile. Des motifs courants qui ne demandent pas beaucoup de raisonnement.
- **Aide sur les commandes shell.** Vous avez oublié une option `git` ou un filtre `jq` ? Gemma 4 vous donne la commande sans passer par Stack Overflow.

## Ses limites

- **Raisonnement multi-étapes.** Les tâches qui demandent une planification sur plusieurs fichiers ou la compréhension d'un flux de contrôle complexe produisent souvent des résultats incomplets.
- **Refactorisations lourdes.** Si vous avez besoin de modifications coordonnées sur l'ensemble d'une base de code, le modèle 8B perd de sa cohérence. Il fonctionne fichier par fichier, mais ne garde pas la vue d'ensemble.
- **Cas limites et bugs subtils.** Gemma 4 détecte les problèmes évidents, mais passe à côté des bugs qui exigent une connaissance approfondie du domaine ou un raisonnement approfondi sur les cas limites.

## Pour aller plus loin : ajouter Haimaker pour les modèles cloud

Gemma 4 en local couvre l'essentiel. Quand vous butez sur un problème qu'il ne sait pas gérer — débogage complexe, refactorisations multi-fichiers, tout ce qui exige un raisonnement approfondi — il vous faut un modèle cloud. [Haimaker](https://haimaker.ai) vous donne une seule clé API pour Claude Opus, GPT-5, Gemini Pro et d'autres.

Ajoutez Haimaker comme second fournisseur, en plus d'Ollama :

```jsonc
{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:latest": {}
      }
    },
    "haimaker": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://api.haimaker.ai/v1"
      },
      "models": {
        "anthropic/claude-sonnet-4-6": {},
        "openai/gpt-5": {},
        "google/gemini-2.5-pro": {}
      }
    }
  }
}
```

Ajoutez votre clé API Haimaker dans le fichier `~/.local/share/opencode/auth.json` :

```json
{
  "ollama": {
    "type": "api",
    "key": "ollama"
  },
  "haimaker": {
    "type": "api",
    "key": "YOUR_HAIMAKER_API_KEY"
  }
}
```

Vous pouvez maintenant basculer entre les modèles locaux et cloud avec `/models` dans OpenCode. Utilisez Gemma 4 pour les tâches rapides. Basculez vers Sonnet ou GPT-5 quand la tâche se complique.

Inscrivez-vous sur [haimaker.ai](https://haimaker.ai) pour obtenir votre clé API et parcourir le [catalogue de modèles](https://haimaker.ai/models).

<a href="https://app.haimaker.ai/sign-up?utm_source=blog&utm_medium=cta&utm_campaign=gemma4-opencode" class="cta-button">OBTENEZ VOTRE CLÉ API HAIMAKER</a>

## Dépannage

**Le fournisseur n'apparaît pas dans /models.** Redémarrez OpenCode après avoir modifié les fichiers de configuration. Les modifications de `opencode.jsonc` ne sont pas prises en compte tant qu'OpenCode est en cours d'exécution.

**Erreur « Model not found ».** Assurez-vous que l'ID du modèle dans votre configuration correspond exactement à celui qu'affiche Ollama. Exécutez `ollama list` et utilisez le nom tel qu'il est affiché — généralement `gemma4:latest`.

**Erreurs d'authentification avec Ollama.** Même si Ollama n'a pas besoin d'authentification, le système de fournisseurs d'OpenCode attend une entrée dans le fichier `auth.json`. La valeur factice `"key": "ollama"` suffit.

**Réponses lentes.** Assurez-vous d'utiliser Ollama v0.19+ pour bénéficier de l'accélération MLX sur Apple Silicon. Exécutez `ollama --version` pour vérifier. Fermez aussi les applications qui monopolisent la mémoire unifiée — les navigateurs avec de nombreux onglets sont généralement en cause.

**Problèmes de fenêtre de contexte.** Gemma 4 prend en charge de grandes fenêtres de contexte, mais sur une machine disposant de 16 Go, maintenez les entrées en dessous de 32 000 tokens pour une qualité de sortie stable. Si vous remarquez une qualité de réponse dégradée avec de longs prompts, c'est probablement la cause.

## Commandes Ollama utiles

| Commande | Description |
|---|---|
| `ollama list` | Lister les modèles téléchargés |
| `ollama ps` | Afficher les modèles en cours d'exécution et l'utilisation de la mémoire |
| `ollama run gemma4:latest` | Chat interactif |
| `ollama stop gemma4:latest` | Décharger le modèle de la mémoire |
| `ollama pull gemma4:latest` | Mettre à jour vers la dernière version |
| `ollama rm gemma4:latest` | Supprimer un modèle |

---

*Vous utilisez déjà Haimaker avec OpenCode ? Consultez le [guide complet de configuration des fournisseurs personnalisés](/blog/how-to-add-haimaker-opencode) pour ajouter davantage de modèles.*