# Claude Code

Source: https://docs.aicentos.com/fr/clients/claude-code

Language: fr

> Installer Claude Code de zéro et le connecter à aicentos : environnement Node.js, installation Windows / Mac, variables d'environnement et configuration CC Switch, avec un tutoriel Termux pour mobile

Claude Code est compatible avec le protocole Anthropic : il suffit de pointer la Base URL vers aicentos et de renseigner votre clé API pour profiter de tous les modèles Claude intégrés par aicentos.

## Étape 1 : installer Claude Code

### Installer l'environnement Node.js

Rendez-vous sur le [site officiel de Node.js](https://nodejs.org/) pour télécharger la dernière version LTS, en choisissant le paquet d'installation correspondant à votre système d'exploitation.

Téléchargement depuis le site officiel de Node.js

Une fois l'installation terminée, ouvrez un terminal (git bash ou cmd sous Windows) et saisissez :

```bash
node -v
```

Si un numéro de version s'affiche, l'installation a réussi.

### Installer Claude Code

Avant l'installation, vérifiez que l'environnement Node.js ci-dessus est bien configuré.

**Windows :** appuyez sur `Win + R`, tapez `cmd` puis Entrée pour ouvrir un terminal, et exécutez :

```bash
npm install -g @anthropic-ai/claude-code
```

**Mac / Linux :** dans un terminal, exécutez :

```bash
npm install -g @anthropic-ai/claude-code
```

ou utilisez le script curl recommandé officiellement :

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

Une fois l'installation terminée, testez qu'elle a réussi :

```bash
claude --version
```

Si un numéro de version s'affiche, l'installation a réussi.

claude --version installé avec succès

## Étape 2 : obtenir une clé API

Rendez-vous dans la console du [site officiel d'aicentos](https://aicentos.com/) pour créer votre clé API.

La procédure détaillée de création d'une clé est décrite dans le [Démarrage rapide](https://docs.aicentos.com/fr/quickstart).

## Étape 3 : configurer la connexion

Deux approches sont possibles : **la gestion centralisée avec CC Switch** (recommandée) ou **la configuration manuelle**.

### Méthode 1 : avec CC Switch (recommandé)

Si vous basculez fréquemment entre plusieurs providers ou plusieurs outils CLI, il est recommandé de centraliser la configuration avec CC Switch, sans avoir à modifier les variables d'environnement en permanence.

Voir [Intégrer CC Switch →](https://docs.aicentos.com/fr/clients/cc-switch)

### Méthode 2 : configuration manuelle

Si vous ne souhaitez pas installer d'outil supplémentaire, il suffit de configurer les variables d'environnement. Trois options au choix.

#### Temporaire (session de terminal actuelle)

Idéal pour un test rapide ; ne reste valable que dans la fenêtre de terminal en cours :

```bash
export ANTHROPIC_BASE_URL="https://aicentos.com"
export ANTHROPIC_AUTH_TOKEN="sk-votre-clé-API"
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
claude
```

Sur certaines versions, si `ANTHROPIC_AUTH_TOKEN` n'est pas reconnu, utilisez plutôt :

```bash
export ANTHROPIC_API_KEY="sk-votre-clé-API"
```

#### Permanent (fichier de configuration, méthode manuelle recommandée)

Éditez `~/.claude/settings.json` avec le contenu suivant :

```bash
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://aicentos.com",
    "ANTHROPIC_AUTH_TOKEN": "sk-votre-clé-API",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "CLAUDE_CODE_ATTRIBUTION_HEADER": "0"
  }
}
```

Sous **Windows**, vous pouvez aussi ouvrir les « variables d'environnement système », section « variables utilisateur », cliquer sur « Nouveau » et créer les deux variables suivantes :

| Nom de la variable     | Valeur                   |
| ---------------------- | ------------------------ |
| `ANTHROPIC_BASE_URL`   | `https://aicentos.com`   |
| `ANTHROPIC_AUTH_TOKEN` | La clé créée à l'étape 2 |

Redémarrez ensuite Claude Code pour que la modification prenne effet.

#### Écriture dans la configuration du shell (effet global)

Ajoutez les variables d'environnement à `~/.zshrc` ou `~/.bashrc` :

```bash
nano ~/.zshrc
```

Ajoutez à la fin du fichier :

```bash
# Clé API aicentos (celle créée à l'étape 2)
export ANTHROPIC_AUTH_TOKEN="votre-clé"

# Base URL aicentos
export ANTHROPIC_BASE_URL="https://aicentos.com"
```

Enregistrez, quittez, puis exécutez `source ~/.zshrc` (ou rouvrez un terminal) pour appliquer.

## Étape 4 : lancer Claude Code

Placez-vous dans votre répertoire de projet et lancez :

```bash
cd /path/to/your/project
claude
```

## Choisir le modèle

Au lancement, utilisez `--model` pour préciser le modèle :

```bash
claude --model claude-opus-4-7
```

Le nom du modèle doit correspondre à ceux listés dans la « place de marché des modèles » de la console aicentos ; voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list).

## Commandes courantes

| Commande                  | Utilité                                                                                     |
| ------------------------- | ------------------------------------------------------------------------------------------- |
| `/add-dir`                | Ajouter un répertoire de travail supplémentaire                                             |
| `/resume`                 | Revenir à une conversation passée                                                           |
| `/clear`                  | Effacer l'historique de la conversation                                                     |
| `/compact [instructions]` | Compacter la conversation, avec des instructions facultatives sur les points à conserver    |
| `/config`                 | Consulter / modifier la configuration                                                       |
| `/cost`                   | Afficher les statistiques de consommation de tokens                                         |
| `/doctor`                 | Vérifier la bonne santé de l'installation de Claude Code                                    |
| `/help`                   | Obtenir de l'aide sur l'utilisation                                                         |
| `/init`                   | Initialiser le projet avec un guide CLAUDE.md                                               |
| `/login`                  | Changer de compte Anthropic                                                                 |
| `/logout`                 | Se déconnecter du compte Anthropic                                                          |
| `/mcp`                    | Gérer les connexions aux serveurs MCP et l'authentification OAuth                           |
| `/memory`                 | Éditer le fichier mémoire CLAUDE.md                                                         |
| `/model`                  | Sélectionner ou changer de modèle IA                                                        |
| `/permissions`            | Consulter ou mettre à jour les permissions                                                  |
| `/pr_comments`            | Consulter les commentaires d'une pull request                                               |
| `/review`                 | Demander une revue de code                                                                  |
| `/status`                 | Afficher l'état du compte et du système                                                     |
| `/terminal-setup`         | Installer le raccourci Shift+Entrée pour le retour à la ligne (iTerm2 et VSCode uniquement) |
| `/vim`                    | Activer le mode vim, pour basculer entre insertion et commandes                             |

## Exécution sur mobile (Termux + Ubuntu)

Adapté aux scénarios du type « pas d'ordinateur sous la main, un bug à corriger en déplacement, envie de vibe coder pendant le trajet ». Sans root, sans flasher le téléphone, le tout depuis Termux. Comptez 10 à 20 minutes au total, selon la vitesse du réseau.

### Ce que vous obtiendrez

* Un environnement **Ubuntu** tournant dans le téléphone (sans impact sur le système, et peu gourmand en espace)
* L'outil en ligne de commande **Claude Code** en version complète (à l'identique de la version ordinateur)
* Une connexion à bas coût via **aicentos**, pour passer en un instant sur Opus / Sonnet / Haiku

### Prérequis

Il ne faut que deux choses :

* **Un téléphone Android** (Termux n'est pas disponible sur iOS, ce tutoriel ne s'y applique pas)
* **Un compte [aicentos](https://aicentos.com) + une clé API** ([recharger le portefeuille →](https://aicentos.com/wallet), [créer une clé →](https://aicentos.com/keys))

**N'installez pas Termux depuis Google Play** : cette version est trop ancienne et n'est plus maintenue, les scripts suivants ne s'y installeraient pas. Téléchargez la dernière version depuis [F-Droid](https://f-droid.org/packages/com.termux/) ou les [Releases GitHub de Termux](https://github.com/termux/termux-app/releases).

### Étape 1 : installer le script tmoe-linux

Ouvrez Termux, attendez l'invite de commandes (une ligne `~ $`), copiez-collez la ligne suivante **en entier** puis validez :

```bash
. <(curl -L l.tmoe.me)
```

>

Il s'agit d'un miroir dédié à la Chine continentale ; les utilisateurs hors Chine utiliseront `. <(curl -L git.io/linux.sh)`.

À la fin de l'exécution, un **menu graphique** apparaît :

Menu principal de tmoe

Naviguez avec les touches de volume, validez avec Entrée (ou touchez directement l'écran).

### Étape 2 : installer le conteneur Ubuntu

Dans le menu tmoe, choisissez successivement `安装 Linux 发行版` / `Install GNU/Linux container` pour accéder à la liste des distributions :

Choix de la distribution Linux

**Ubuntu est vivement recommandé** (la meilleure compatibilité, le plus de documentation apt, des réponses faciles à trouver en cas de problème). Prenez la dernière LTS (par exemple 22.04 / 24.04).

Le téléchargement + l'extraction prennent quelques minutes selon le réseau ; patiencez.

### Étape 3 : entrer dans le conteneur et savoir « où vous en êtes »

Une fois l'installation terminée, vous entrez probablement automatiquement dans le conteneur. **C'est l'étape où les débutants se perdent le plus facilement** ; voici comment faire la différence :

**Vous êtes dans le conteneur Ubuntu** (l'invite ressemble à ceci) :

Invite dans le conteneur

**Vous êtes toujours dans Termux** (l'invite est plus sobre) :

Invite hors du conteneur

Dans le second cas, revenez dans Termux et saisissez :

```bash
tmoe
```

Rouvrez le menu et choisissez `启动容器` / `Start container` pour y entrer.

**Retenez cette règle** : installer Node, installer Claude Code, lancer la commande claude — **tout cela doit se faire dans le conteneur Ubuntu**. Le système de paquets `pkg` de Termux ne permet pas d'installer Claude Code.

### Étape 4 : installer Node.js et Claude Code

Une fois que vous êtes bien dans le conteneur Ubuntu, exécutez successivement :

```bash
# 1. Mettre à jour l'index des paquets apt
apt update

# 2. Installer Node.js + npm (la version fournie par Ubuntu suffit)
apt install -y nodejs npm

# 3. Installer Claude Code globalement
npm install -g @anthropic-ai/claude-code
```

Si npm signale une erreur de permissions, ajoutez `sudo` devant. S'il n'y a pas de commande `sudo`, c'est que vous êtes root : exécutez directement.

### Étape 5 : connecter Claude Code à aicentos

Par défaut, Claude Code se connecte au service officiel, ce qui pose deux problèmes pour la Chine : **pas de quota, et impossible de se connecter**.

Modifions deux variables d'environnement pour le pointer vers aicentos :

```bash
# 1. Installer l'éditeur de texte nano (souvent absent du conteneur)
apt install -y nano

# 2. Éditer la configuration de votre shell
nano ~/.bashrc
```

Déplacez le curseur **tout à la fin** du fichier, ajoutez une nouvelle ligne et collez :

```bash
export ANTHROPIC_BASE_URL=https://aicentos.com
export ANTHROPIC_AUTH_TOKEN=votre-clé-API-générée-sur-aicentos.com
```

Remplacez `votre-clé-API-générée-sur-aicentos.com` par la clé API créée dans la [console aicentos](https://aicentos.com/keys) (commençant en général par `sk-`).

Le résultat ressemble à ceci :

Variables d'environnement ajoutées en fin de bashrc

**Enregistrez et quittez** :

* Appuyez sur `Ctrl + X` (touche Ctrl du clavier virtuel, présente par défaut dans Termux)
* À la demande de sauvegarde, appuyez sur `Y`
* Puis `Enter` pour confirmer le nom du fichier

Pour appliquer immédiatement la configuration :

```bash
source ~/.bashrc
```

### Étape 6 : démarrage

```bash
claude
```

**Au premier lancement**, on vous demande de choisir le mode de connexion :

* Si vous vous étiez déjà connecté avec un compte officiel et souhaitez l'effacer, tapez `/logout` dans Claude Code ; après déconnexion, relancez `claude` et vos variables d'environnement seront utilisées
* Sur une installation toute neuve, l'étape peut être passée et les variables d'environnement utilisées directement

Dès que la boîte de dialogue de Claude Code apparaît, c'est gagné ; posez une question pour tester :

```bash
Bonjour, écris-moi un script Python « hello world »
```

### Aide-mémoire des commandes sur mobile

Dans Claude Code :

| Commande   | Rôle                                                                                                    |
| ---------- | ------------------------------------------------------------------------------------------------------- |
| `/model`   | Changer de modèle (Opus / Sonnet / Haiku)                                                               |
| `/logout`  | Se déconnecter du compte courant (à utiliser une fois après un changement de variables d'environnement) |
| `/clear`   | Effacer le contexte de la session en cours                                                              |
| `/help`    | Voir toutes les commandes                                                                               |
| `Ctrl + C` | Interrompre la génération en cours                                                                      |

Hors du conteneur (dans Termux) :

| Commande            | Rôle                               |
| ------------------- | ---------------------------------- |
| `tmoe`              | Ouvrir le menu principal de tmoe   |
| Lancer le conteneur | choisir « 启动容器 » dans le menu tmoe |

### Pièges courants sur mobile

**1. `npm install -g` ne démarre pas / se bloque**

Sans doute le réseau. Dans le conteneur, vous pouvez d'abord exécuter `npm config set registry https://registry.npmmirror.com` pour passer sur le miroir Taobao, puis relancer `npm install -g @anthropic-ai/claude-code`.

**2. La commande `claude` est introuvable (not found)**

Le chemin des commandes installées par `npm install -g` n'est pas dans le `PATH`. Ajoutez à la fin de `~/.bashrc` :

```bash
export PATH="$PATH:$(npm config get prefix)/bin"
```

puis `source ~/.bashrc`.

**3. Erreur 401 / solde insuffisant**

Vérifiez le solde du [portefeuille aicentos](https://aicentos.com/wallet), et que `ANTHROPIC_AUTH_TOKEN` a été copié intégralement (attention aux espaces en début et fin).

**4. Vous voulez un Sonnet et éviter que Opus ne brûle votre crédit**

Après avoir lancé `claude`, tapez `/model` et choisissez sonnet. Ou fixez le modèle par défaut en ajoutant `export ANTHROPIC_MODEL=claude-sonnet-5` dans `.bashrc`.

### Pour aller plus loin sur mobile

* Pour une saisie plus confortable : installez [Termux:Styling](https://f-droid.org/packages/com.termux.styling/) pour changer la police et les couleurs
* Pour une interface graphique : le menu tmoe propose un bureau VNC, de quoi faire tourner un GNOME/XFCE complet sur le téléphone
* Pour un fonctionnement de longue durée en arrière-plan : utilisez `tmux` ou `screen`, la session survit à la fermeture de Termux

Le tutoriel s'arrête ici. Pour tout problème, n'hésitez pas à le signaler à la [communauté aicentos](https://aicentos.com).

## Remarques

* La clé API s'obtient sur la page « Clés API » de la console.
* `ANTHROPIC_AUTH_TOKEN` et `ANTHROPIC_API_KEY` : **choisissez l'un des deux, ne définissez jamais les deux à la fois**.
* La Base URL ne doit contenir que l'adresse racine `https://aicentos.com` ; **n'ajoutez pas** manuellement `/v1/messages`, Claude Code le fait lui-même.
* Après toute modification de la configuration, pensez à redémarrer le terminal / Claude Code.
* Ne commitez jamais votre clé API dans un dépôt de code.