Ollama pour faire tourner Claude Code gratuitement en local

Salut la commu !

Comme pas mal d’entre vous, je bavais d’envie devant Claude Code, l’assistant de codage dans le terminal qu’Anthropic a sorti récemment. Mais honnêtement, l’idée de lier ma carte bancaire et de stresser sur ma facture d’API à chaque fois que l’outil scanne mon projet me refroidissait un peu.

La bonne nouvelle ? Ollama est entièrement compatible avec l’API Messages d’Anthropic. On peut donc faire tourner Claude Code gratuitement en utilisant nos modèles open-source locaux (ou via des modèles cloud légers).

Après pas mal de bidouilles pour éviter que ma machine ne se transforme en radiateur poussif, j’ai enfin un setup ultra-fluide. Voici comment faire la même chose chez vous, étape par étape, sans vous arracher les cheveux.

Étape 1 : Installer les outils de base

Avant de commencer, il vous faut Ollama et le CLI officiel de Claude Code installés sur votre machine.

1. Pour installer Ollama (si ce n’est pas déjà fait) :

• Sur macOS / Linux :
  bash curl -fsSL https://ollama.com/install.sh | sh
• Sur Windows (via PowerShell) :
  powershell winget install Ollama.Ollama

2. Pour installer Claude Code :

• Sur macOS / Linux :
  bash curl -fsSL https://claude.ai/install.sh | bash
• Sur Windows (PowerShell en mode Admin) :
  powershell irm https://claude.ai | iex

Étape 2 : Le choix du modèle (Le nerf de la guerre)

Pour que Claude Code soit efficace, il lui faut un modèle capable de gérer le “tool calling” (pour exécuter des commandes et lire des fichiers) et doté d’une grande fenêtre de contexte. J’en ai testé plusieurs, et voici mon verdict :

• Le champion local : qwen3-coder. C’est la référence absolue. Il gère des contextes gigantesques (jusqu’à 256k) et comprend les correctifs (“patches”) comme un chef.
  • Si vous avez un gros GPU (24 Go de VRAM+) : prenez la version 30b.
  • Sur un laptop standard (8-16 Go de RAM) : la version 7b suffit amplement.
• L’alternative Cloud gratuite : glm-5:cloud (ou glm-4.7:cloud). Si votre PC rame, Ollama permet de déporter le calcul sur ce modèle tiers gratuit. C’est ultra-rapide et très intelligent.
• Le spécialiste multi-fichiers : gpt-oss:20b. Très stable pour suivre l’état du code sur plusieurs fichiers.

Pour mon exemple, on va télécharger le modèle recommandé :

ollama pull qwen3-coder

Étape 3 : Lancer l’assistant (Le moyen rapide vs manuel)

Le moyen le plus simple d’éviter de s’embêter avec des variables d’environnement complexes est d’utiliser la commande native d’Ollama.

Allez dans le dossier de votre projet de code et tapez simplement :

ollama launch claude

Ollama va s’occuper de tout configurer en arrière-plan et lancer l’interface interactive.

Et si ça ne marche pas ? (La méthode manuelle)

Parfois, le couplage automatique a des ratés. Dans ce cas, vous pouvez forcer la redirection manuellement en déclarant les variables d’environnement avant de lancer l’outil.

• Sur macOS / Linux : export ANTHROPIC_AUTH_TOKEN=ollama export ANTHROPIC_BASE_URL=http://localhost:11434 export ANTHROPIC_API_KEY="ollama" claude --model qwen3-coder
• Sur Windows (PowerShell) : $env:ANTHROPIC_AUTH_TOKEN="ollama" $env:ANTHROPIC_BASE_URL="http://localhost:11434" $env:ANTHROPIC_API_KEY="ollama" claude --model qwen3-coder

Gestion des permissions

À la première exécution, répondez Y (Yes) quand Claude vous demande d’accéder à vos fichiers locaux.

• Astuce utile : Tapez /permissions directement dans le chat pour vérifier que les accès au système de fichiers et au terminal sont bien définis sur Allow.
• Si vous travaillez dans un conteneur Docker ou un environnement totalement isolé, vous pouvez ajouter le drapeau --dangerously-skip-permissions au lancement pour que l’IA travaille en autonomie totale sans vous demander de validation à chaque modification de fichier.

Étape 4 : Les optimisations indispensables (Pour ne pas que ça rame)

Le vrai piège, c’est la taille du contexte. Par défaut, Ollama limite souvent le contexte à 4 096 tokens. C’est beaucoup trop court pour analyser l’architecture d’un projet, ce qui fait que Claude Code va vite “oublier” vos fichiers.

Mais si on augmente bêtement le contexte à 64k tokens, la consommation de VRAM s’envole, le modèle déborde sur le CPU et l’écriture se met à ramer au point de générer du texte mot par mot. (Franchement, au début, j’ai cru que j’allais casser ma carte graphique…)

Voici comment j’ai résolu ça :

1. Augmenter le contexte proprement (Via un Modelfile)

Plutôt que de bidouiller les variables d’environnement à chaque démarrage, créez un fichier nommé Modelfile (sans extension) dans un dossier et écrivez ceci :

FROM qwen3-coder
PARAMETER num_ctx 64000

Compilez ce modèle personnalisé :

ollama create qwen3-coder-64k -f ./Modelfile

Vous pouvez désormais le lancer directement : claude --model qwen3-coder-64k.

2. Activer la quantification du cache K/V (La formule magique)

C’est ce qui m’a sauvé. Compresser le cache K/V (Key/Value) réduit drastiquement l’empreinte mémoire d’Ollama sur les grands contextes.

Quittez complètement votre application Ollama, puis relancez le serveur dans votre terminal avec ces paramètres :

• Sur macOS :
  bash OLLAMA_FLASH_ATTENTION=1 OLLAMA_KV_CACHE_TYPE=q8_0 ollama serve
• Sur Windows (PowerShell) :
  powershell $env:OLLAMA_FLASH_ATTENTION="1" $env:OLLAMA_KV_CACHE_TYPE="q8_0" ollama serve

Le mode q8_0 (quantification 8-bits) divise par deux la VRAM nécessaire pour l’historique de conversation sans perte de précision visible.

Si vous avez une petite config (GPU de 6 ou 8 Go), passez carrément en q4_0 (quantification 4-bits) : cela économise jusqu’à 75 % de VRAM ! Par exemple, pour un contexte de 64k avec Qwen3-Coder, le besoin en VRAM pour le cache passe d’environ 10 Go (en f16 par défaut) à seulement 2 ou 3 Go.

3. Comment vérifier que tout tourne sur le GPU ?

Pendant que Claude Code est en train d’analyser vos fichiers, ouvrez un second terminal et lancez :

ollama ps

Regardez la colonne VRAM et CONTEXT. Si votre modèle est chargé à 100% en VRAM, c’est parfait. S’il affiche un pourcentage hybride (ex: 80% GPU / 20% CPU), c’est qu’il déborde sur votre processeur. Dans ce cas :

• Forcez la quantification en q4_0.
• Ou utilisez une version plus légère du modèle, comme qwen3-coder:7b-instruct-q4_K_M.
• Ou réduisez simplement le contexte à 32 000 ou 16 000 tokens en modifiant votre variable OLLAMA_CONTEXT_LENGTH ou votre Modelfile.

Voilà, vous avez un copilote de terminal surpuissant, totalement privé, gratuit, et qui ne fera pas fondre votre carte graphique si vous appliquez ces quelques optimisations.

Des gens ici ont déjà testé d’autres modèles open-source sur ce setup ? Des retours sur la gestion des projets complexes à plusieurs dossiers ?