Pourquoi votre futur IDE pourrait tourner SANS internet en 2026 ?

Imaginez un monde où votre éditeur de code fonctionne sans connexion internet, sans abonnement mensuel, et sans attendre que le serveur distant veuille bien répondre. Ce monde existe déjà en 2026. Les modèles d'IA locaux sont désormais assez bons pour gérer la plupart des tâches quotidiennes de Développement : compléter du code, le réorganiser, déboguer, ou même expliquer un projet entier. Le tout, gratuitement et sans limite de temps. Plus besoin de payer 20 dollars par mois pour 100 requêtes, ni de subir des coupures en pleine session de travail.

POURQUOI PASSER AU LOCAL EST UNE BONNE IDÉE

Une session de développement agentique (où l'IA écrit, teste et améliore le code toute seule) peut coûter 10 à 50 fois plus cher qu'une simple conversation. À l'échelle d'un projet, la facture explose vite. Ajoutez à ça les limites de taux qui peuvent interrompre votre travail en plein milieu d'une session complexe, et la dépendance à une API tierce qui peut changer ses tarifs ou ses règles du jour au lendemain… et la solution locale devient évidente. Plus de surprise désagréable, plus de dépendance à un service externe.

Les modèles locaux en 2026 sont désormais capables de remplacer les tâches quotidiennes de Claude Code sans rien sacrifier en qualité. Le tout, avec un coût par requête proche de zéro et aucune limite de temps. Cet article vous explique comment configurer trois solutions différentes (Ollama, LM Studio et llama.cpp) pour utiliser Claude Code avec vos propres modèles. Vous y trouverez les variables d'environnement exactes à configurer, les fichiers de configuration à modifier, une sélection de modèles recommandés, et les solutions aux problèmes les plus courants.

LE PRINCIPE DE FONCTIONNEMENT : COMMENT CLAUDE CODE PARLE À VOS MODÈLES LOCAUX

Claude Code envoie ses requêtes dans le format de l'API Messages d'Anthropic. Par défaut, ces requêtes partent vers les serveurs d'Anthropic. Mais il suffit de modifier une variable d'environnement pour rediriger ces requêtes vers n'importe quel serveur qui parle le même langage. C'est exactement ce que font Ollama, LM Studio et llama.cpp depuis début 2026.

Trois variables d'environnement sont cruciales pour cette configuration :

• ANTHROPICDEFAULTSONNET_MODEL
• ANTHROPICDEFAULTHAIKU_MODEL
• ANTHROPICDEFAULTOPUS_MODEL

Ces variables permettent de mapper les trois niveaux de modèles utilisés par Claude Code (Sonnet, Haiku, Opus) vers le nom exact de votre modèle local. Sans elles, Claude Code enverrait une requête pour claude-sonnet-4-20250514 à votre serveur local… qui rejetterait la demande parce que ce modèle n'existe pas chez vous.

En janvier 2026, Ollama a ajouté une prise en charge native de l'API Messages d'Anthropic. LM Studio a fait de même dans sa version 0.4.1 avec un endpoint /v1/messages compatible. Quant à llama.cpp, il supporte directement le protocole API d'Anthropic depuis plus longtemps. Les trois solutions parlent désormais le même langage que Claude Code, sans besoin de proxy ni de traduction.

OPTION 1 : OLLAMA, LA SOLUTION LA PLUS SIMPLE POUR DÉBUTER

Ollama est souvent le meilleur point de départ pour les débutants. Il gère toute la complexité technique en arrière-plan : téléchargement des poids, quantification, allocation GPU/CPU, et mise en service. Tout cela derrière une interface en ligne de commande ultra-simple. Un seul commande pour installer, un seul commande pour télécharger un modèle, quelques variables d'environnement pour configurer. Et le tout fonctionne en arrière-plan après l'installation, sans besoin de lancer manuellement un serveur.

Installation sur macOS et Linux

# Installation en une commande
curl -fsSL https://ollama.com/install.sh | sh

# Vérification de la version (doit être 0.14.0 ou supérieure pour la compatibilité avec Claude Code)
ollama version
# Résultat attendu : ollama version est 0.14.x ou supérieure

# Sous Windows : téléchargez l'installateur depuis https://ollama.com
# Le support natif de Windows s'est considérablement amélioré dans les dernières versions

Vérification que Ollama tourne

# Vérifiez que le serveur Ollama est actif
curl http://localhost:11434

# Résultat attendu :
# Ollama is running

Téléchargement des modèles recommandés

Ollama propose plusieurs modèles optimisés pour le développement. Voici les trois à essayer en premier :

# GLM-4.7-Flash : modèle recommandé pour commencer
# Excellente capacité d'appel d'outils, contexte de 128K, tient sur 8 Go de VRAM
# Licence Apache 2.0
ollama pull glm-4.7-flash:latest

# Qwen3-Coder : fort pour la génération de code et le suivi d'instructions
# Nécessite 20 Go de VRAM ou plus pour le modèle complet
ollama pull qwen3-coder

# Devstral-Small : conçu spécifiquement pour les workflows de développement agentique
# Testé par la communauté pour la compatibilité avec Claude Code
# 24 milliards de paramètres, nécessite 16 Go de VRAM ou plus
ollama pull devstral-small-2:24b

# Vérification des modèles téléchargés
ollama list
# Affiche tous les modèles avec leurs tailles et dates de modification

Configuration pour utiliser Ollama avec Claude Code

Trois méthodes principales existent pour rediriger Claude Code vers Ollama. Choisissez celle qui correspond le mieux à votre workflow.

Méthode 1 : Variables d'environnement dans le terminal (session actuelle uniquement)

# Redirigez les requêtes de Claude Code vers votre serveur Ollama local
export ANTHROPICBASEURL="http://localhost:11434"

# Les serveurs locaux n'ont pas besoin d'authentification réelle
# Mettez n'importe quelle chaîne non vide, Ollama ignore la valeur
export ANTHROPICAPIKEY="ollama"
export ANTHROPICAUTHTOKEN="ollama"

# Mappez les niveaux de modèles de Claude Code vers votre modèle local
# Claude Code demande internement sonnet/haiku/opus, ces variables
# traduisent ces noms vers le modèle que vous avez téléchargé
export ANTHROPICDEFAULTSONNET_MODEL="glm-4.7-flash:latest"
export ANTHROPICDEFAULTHAIKU_MODEL="glm-4.7-flash:latest"
export ANTHROPICDEFAULTOPUS_MODEL="glm-4.7-flash:latest"

# Lancez Claude Code : il utilisera désormais Ollama au lieu de l'API d'Anthropic
claude

Méthode 2 : Configuration permanente via ~/.claude/settings.json

Cette approche survit aux redémarrages du terminal et s'applique à chaque lancement de Claude Code. Le fichier settings.json est lu au démarrage pour configurer les variables d'environnement.

~/.claude/settings.json

{
  "env": {
    "ANTHROPICBASEURL": "http://localhost:11434",
    "ANTHROPICAPIKEY": "ollama",
    "ANTHROPICAUTHTOKEN": "ollama",
    "ANTHROPICDEFAULTSONNET_MODEL": "glm-4.7-flash:latest",
    "ANTHROPICDEFAULTHAIKU_MODEL": "glm-4.7-flash:latest",
    "ANTHROPICDEFAULTOPUS_MODEL": "glm-4.7-flash:latest"
  }
}

Méthode 3 : Fichier .env dans le répertoire du projet (par projet)

Si vous souhaitez qu'un projet spécifique utilise un modèle différent tout en gardant vos paramètres globaux sur l'API d'Anthropic :

# .env dans la racine de votre projet
# Chargé automatiquement par Claude Code
ANTHROPICBASEURL=http://localhost:11434
ANTHROPICAPIKEY=ollama
ANTHROPICAUTHTOKEN=ollama
ANTHROPICDEFAULTSONNET_MODEL=qwen3-coder
ANTHROPICDEFAULTHAIKU_MODEL=qwen3-coder
ANTHROPICDEFAULTOPUS_MODEL=qwen3-coder

Test de fonctionnement

# Lancez Claude Code avec une requête simple
claude

# À l'intérieur de Claude Code, testez avec une requête basique :
# > Quel modèle utilises-tu ?
# Un modèle local doit répondre sans faire d'appel à l'API d'Anthropic.

# Pour confirmer qu'aucun appel externe n'est effectué, lancez avec une journalisation détaillée :
claude --verbose

# Cherchez des lignes indiquant que les requêtes vont vers localhost:11434
# plutôt que vers api.anthropic.com

Résumé des commandes clés pour Ollama

curl -fsSL https://ollama.com/install.sh | sh          # 1. Installer Ollama
ollama pull glm-4.7-flash:latest                       # 2. Télécharger le modèle (~4 Go)
export ANTHROPICBASEURL="http://localhost:11434"     # 3. Rediriger Claude Code
export ANTHROPICAPIKEY="ollama"                      # 4. Définir une authentification fictive
export ANTHROPICAUTHTOKEN="ollama"
export ANTHROPICDEFAULTSONNET_MODEL="glm-4.7-flash:latest"
export ANTHROPICDEFAULTHAIKU_MODEL="glm-4.7-flash:latest"
export ANTHROPICDEFAULTOPUS_MODEL="glm-4.7-flash:latest"
claude                                                  # 5. Lancer

OPTION 2 : LM STUDIO, LA SOLUTION AVEC INTERFACE GRAPHIQUE

Si vous préférez une interface graphique pour parcourir et gérer vos modèles plutôt que de tout faire en ligne de commande, LM Studio est fait pour vous. Depuis la version 0.4.1, il inclut un endpoint natif /v1/messages compatible avec l'API d'Anthropic. Plus besoin de couche de traduction ni de proxy.

Installation sur serveur ou machine virtuelle sans interface graphique

# Définissez l'URL de base vers le serveur local de LM Studio
export ANTHROPICBASEURL="http://localhost:1234"
export ANTHROPICAPIKEY="lm-studio"
export ANTHROPICAUTHTOKEN="lm-studio"

# Remplacez le nom du modèle par celui que LM Studio affiche pour votre modèle chargé
# Copiez-le exactement, y compris les suffixes de version ou de quantification
export ANTHROPICDEFAULTSONNET_MODEL="qwen2.5-coder-32b-instruct"
export ANTHROPICDEFAULTHAIKU_MODEL="qwen2.5-coder-32b-instruct"
export ANTHROPICDEFAULTOPUS_MODEL="qwen2.5-coder-32b-instruct"

Configuration permanente via ~/.claude/settings.json

~/.claude/settings.json

{
  "env": {
    "ANTHROPICBASEURL": "http://localhost:1234",
    "ANTHROPICAPIKEY": "lm-studio",
    "ANTHROPICAUTHTOKEN": "lm-studio",
    "ANTHROPICDEFAULTSONNET_MODEL": "qwen2.5-coder-32b-instruct",
    "ANTHROPICDEFAULTHAIKU_MODEL": "qwen2.5-coder-32b-instruct",
    "ANTHROPICDEFAULTOPUS_MODEL": "qwen2.5-coder-32b-instruct"
  }
}

Procédure complète pour LM Studio

# 1. Démarrez le serveur LM Studio depuis l'interface graphique (onglet Local Server > Start Server)
# 2. Définissez les variables d'environnement
export ANTHROPICBASEURL="http://localhost:1234"
export ANTHROPICAPIKEY="lm-studio"
export ANTHROPICAUTHTOKEN="lm-studio"
export ANTHROPICDEFAULTSONNET_MODEL="votre-nom-de-modele-ici"
export ANTHROPICDEFAULTHAIKU_MODEL="votre-nom-de-modele-ici"
export ANTHROPICDEFAULTOPUS_MODEL="votre-nom-de-modele-ici"
# 3. Lancez
claude

OPTION 3 : LLAMA.CPP, LA SOLUTION POUR LES EXPERTS ET LES SERVEURS

llama.cpp est la solution idéale si vous voulez un contrôle total sur votre infrastructure ou si vous travaillez sur un serveur sans interface graphique. C'est un moteur d'inférence ultra-rapide écrit en C/C++, optimisé pour tourner sur CPU ou GPU.

Installation sur macOS

# La méthode la plus simple sous macOS est Homebrew
brew install llama.cpp

Installation sur Linux avec GPU (NVIDIA)

# Clonez le dépôt et compilez avec prise en charge CUDA pour de meilleures performances
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON          # Active l'accélération CUDA
cmake --build build --config Release   # Compilation
# Les binaires se trouvent dans ./build/bin/

# Pour une compilation CPU-only sous Linux
cmake -B build
cmake --build build --config Release

Installation sur Windows

# Des binaires pré-compilés sont disponibles à l'adresse :
# https://github.com/ggml-org/llama.cpp/releases
# Téléchargez la variante CUDA ou CPU correspondant à votre matériel

Téléchargement des modèles quantifiés

llama.cpp utilise des fichiers au format GGUF, optimisés pour l'inférence locale. Voici comment télécharger les modèles recommandés :

# Installez l'interface en ligne de commande de Hugging Face si ce n'est pas déjà fait
pip install huggingface-hub

# Téléchargez GLM-4.7-Flash en quantification Q4KXL (~4,5 Go)
# Cette quantification offre un bon équilibre taille/qualité pour le développement
huggingface-cli download unsloth/GLM-4.7-Flash-GGUF \
  GLM-4.7-Flash-UD-Q4KXL.gguf \
  --local-dir ./models/

# Ou téléchargez Qwen3-Coder en quantification Q4 (~15 Go pour la version 32B)
huggingface-cli download Qwen/Qwen3-Coder-32B-Instruct-GGUF \
  qwen3-coder-32b-instruct-q4km.gguf \
  --local-dir ./models/

Lancement du serveur llama.cpp

Le serveur llama-server doit être lancé avec les bons paramètres pour supporter le protocole API d'Anthropic et gérer des bases de code importantes.

# Démarrez le serveur avec prise en charge de l'API Anthropic et une fenêtre de contexte de 128K
llama-server \
  --model ./models/GLM-4.7-Flash-UD-Q4KXL.gguf \
  --alias "glm-4.7-flash" \          # Ce nom doit correspondre à ANTHROPICDEFAULTSONNET_MODEL
  --port 8001 \
  --ctx-size 131072 \                # Fenêtre de contexte de 128K, importante pour les gros projets
  --flash-attn \                     # Attention flash memory-efficient, améliore la vitesse
  --n-gpu-layers 99                  # Charge toutes les couches sur le GPU ; retirez pour CPU-only

# Pour une inférence CPU-only (sans GPU) :
llama-server \
  --model ./models/GLM-4.7-Flash-UD-Q4KXL.gguf \
  --alias "glm-4.7-flash" \
  --port 8001 \
  --ctx-size 32768 \                 # Réduisez la taille du contexte sur CPU pour gérer la mémoire
  --threads 8                        # Adaptez au nombre de cœurs de votre CPU

Configuration pour utiliser llama.cpp avec Claude Code

# Définissez l'URL de base vers votre serveur llama.cpp local
export ANTHROPICBASEURL="http://localhost:8001"
export ANTHROPICAPIKEY="llama-cpp"
export ANTHROPICAUTHTOKEN="llama-cpp"

# Doit correspondre exactement au --alias passé à llama-server
# Exemple : si vous avez utilisé --alias "glm-4.7-flash", utilisez ce nom ici
export ANTHROPICDEFAULTSONNET_MODEL="glm-4.7-flash"
export ANTHROPICDEFAULTHAIKU_MODEL="glm-4.7-flash"
export ANTHROPICDEFAULTOPUS_MODEL="glm-4.7-flash"

Lancement en deux terminaux

# Terminal 1 : démarrez le serveur llama.cpp
llama-server \
  --model ./models/GLM-4.7-Flash-UD-Q4KXL.gguf \
  --alias "glm-4.7-flash" \
  --port 8001 \
  --ctx-size 131072 \
  --flash-attn \
  --n-gpu-layers 99

# Terminal 2 : configurez et lancez Claude Code
export ANTHROPICBASEURL="http://localhost:8001"
export ANTHROPICAPIKEY="llama-cpp"
export ANTHROPICAUTHTOKEN="llama-cpp"
export ANTHROPICDEFAULTSONNET_MODEL="glm-4.7-flash"
export ANTHROPICDEFAULTHAIKU_MODEL="glm-4.7-flash"
export ANTHROPICDEFAULTOPUS_MODEL="glm-4.7-flash"
claude

Configuration permanente via ~/.claude/settings.json

~/.claude/settings.json

{
  "env": {
    "ANTHROPICBASEURL": "http://localhost:11434",
    "ANTHROPICAPIKEY": "ollama",
    "ANTHROPICAUTHTOKEN": "ollama",
    "ANTHROPICDEFAULTSONNET_MODEL": "glm-4.7-flash:latest",
    "ANTHROPICDEFAULTHAIKU_MODEL": "glm-4.7-flash:latest",
    "ANTHROPICDEFAULTOPUS_MODEL": "glm-4.7-flash:latest",
    "CLAUDECODEDISABLEEXPERIMENTALBETAS": "1"
  }
}

Désactivation des bêta expérimentaux

Certaines versions de Claude Code peuvent rencontrer des erreurs liées aux en-têtes d'API expérimentaux. Pour les désactiver :

CLAUDECODEDISABLEEXPERIMENTALBETAS: "1"

RÉSOLUTION DES PROBLÈMES COURANTS

Erreur : Valeurs inattendues pour l'en-tête anthropic-beta

Cette erreur apparaît lorsque vous essayez de lancer une version de Claude Code qui n'est pas compatible avec les modèles locaux. La solution est simple : désactivez les fonctionnalités bêta expérimentales.

# Script pour basculer vers Ollama
# use-local.sh
export ANTHROPICBASEURL="http://localhost:11434"
export ANTHROPICAPIKEY="ollama"
export ANTHROPICAUTHTOKEN="ollama"
export ANTHROPICDEFAULTSONNET_MODEL="glm-4.7-flash:latest"
export ANTHROPICDEFAULTHAIKU_MODEL="glm-4.7-flash:latest"
export ANTHROPICDEFAULTOPUS_MODEL="glm-4.7-flash:latest"
echo "Claude Code → Ollama local (glm-4.7-flash)"

# Script pour revenir à l'API d'Anthropic
# use-anthropic.sh
unset ANTHROPICBASEURL
unset ANTHROPICAUTHTOKEN
unset ANTHROPICDEFAULTSONNET_MODEL
unset ANTHROPICDEFAULTHAIKU_MODEL
unset ANTHROPICDEFAULTOPUS_MODEL
# ANTHROPICAPIKEY doit déjà être défini dans votre fichier rc avec votre clé réelle
echo "Claude Code → API Anthropic"

# Utilisation des scripts
source ./use-local.sh
claude

# Pour une tâche complexe nécessitant l'API réelle :
source ./use-anthropic.sh
claude

Vérification que les serveurs locaux tournent

# Vérifiez si Ollama est actif
curl http://localhost:11434
# Résultat attendu : "Ollama is running"

# Vérifiez si le serveur LM Studio est actif
curl http://localhost:1234/v1/models
# Doit retourner une liste JSON des modèles chargés

# Vérifiez si llama-server est actif
curl http://localhost:8001/health
# Doit retourner {"status":"ok"}

# Si aucun serveur ne tourne, lancez-le avant de lancer Claude Code
ollama serve          # Ollama
# LM Studio : utilisez l'onglet Local Server dans l'interface graphique
# llama.cpp : exécutez la commande llama-server depuis la section Backend 3

Vérification du nom exact du modèle

Le nom du modèle dans ANTHROPICDEFAULTSONNET_MODEL doit correspondre exactement, y compris le tag. Par exemple, glm-4.7-flash:latest et non glm-4.7-flash.

# Liste tous les modèles disponibles dans Ollama
ollama list

# Vérifiez avec un appel API direct pour confirmer ce que le serveur voit
curl http://localhost:11434/v1/models

Mise à jour d'Ollama

Si vous utilisez une version d'Ollama antérieure à la 0.14.3, une mise à jour est nécessaire pour la compatibilité avec Claude Code.

# Vérifiez votre version d'Ollama
ollama version

# Si la version est inférieure à 0.14.3, mettez à jour
curl -fsSL https://ollama.com/install.sh | sh

Désactivation de la redirection locale

Pour revenir à l'API d'Anthropic, supprimez les variables d'environnement dans votre session shell ou commentez le bloc dans settings.json.

# Dans votre session shell, supprimez les variables de redirection
unset ANTHROPICBASEURL
unset ANTHROPICAUTHTOKEN
unset ANTHROPICDEFAULTSONNET_MODEL
unset ANTHROPICDEFAULTHAIKU_MODEL
unset ANTHROPICDEFAULTOPUS_MODEL

# Vérifiez que votre clé API réelle est définie
# Elle doit ressembler à sk-ant-.
echo $ANTHROPICAPIKEY

# Si vous avez utilisé settings.json, supprimez ou commentez le bloc env
# puis redémarrez Claude Code

Optimisation des couches GPU avec Ollama

Par défaut, Ollama charge toutes les couches sur le GPU si disponible. Vous pouvez ajuster ce comportement avec la variable OLLAMANUMGPU_LAYERS.

OLLAMANUMGPU_LAYERS=99

SÉLECTION DE MODÈLES LOCAUX À ESSAYER

Voici une liste de modèles recommandés pour le développement avec Claude Code, classés par catégorie.

Modèles recommandés pour Ollama

# GLM-4.7-Flash : équilibre parfait pour la plupart des usages
ollama pull glm-4.7-flash

# Devstral-Small : conçu pour les workflows agentiques
ollama pull devstral-small-2:24b

# Qwen3-Coder : excellent pour la génération et le suivi d'instructions
ollama pull qwen3-coder

# Qwen3.5 : alternative récente et performante
ollama pull qwen3.5:27b

# Gemma4 : modèle compact et efficace
ollama pull gemma4:26b

Vérification des serveurs locaux

# Vérifiez si Ollama est en cours d'exécution
curl http://localhost:11434
# Résultat attendu : "Ollama is running"

# Vérifiez si LM Studio est en cours d'exécution
curl http://localhost:1234/v1/models
# Doit retourner une liste JSON des modèles chargés

# Vérifiez si llama-server est en cours d'exécution
curl http://localhost:8001/health
# Doit retourner {"status":"ok"}

# Si un serveur ne tourne pas, lancez-le avant de lancer Claude Code
ollama serve          # Ollama
# LM Studio : utilisez l'interface graphique pour démarrer le serveur
# llama.cpp : exécutez la commande depuis la section Backend 3

CONCLUSION : VERS UNE ÈRE DU CODAGE SANS INTERNET

En 2026, les modèles locaux sont enfin assez puissants pour remplacer la plupart des fonctionnalités de Claude Code. Plus besoin de payer par requête, plus de limites de temps, plus de dépendance à un service externe. Avec une configuration simple de trois variables d'environnement, vous pouvez transformer votre éditeur de code en une machine à coder autonome, gratuite et sans interruption.

Ollama reste la solution la plus accessible pour la plupart des utilisateurs. LM Studio convient à ceux qui préfèrent une interface graphique. llama.cpp offre le contrôle maximal pour les experts et les serveurs. Quel que soit votre choix, le résultat est le même : un workflow de développement plus rapide, plus fiable et moins cher.

Le futur du développement ne passera pas forcément par le cloud. Il passera peut-être par votre propre machine, avec vos propres modèles, et une liberté totale de coder quand vous voulez, où vous voulez.