# Guide d'Installation de Claude Code

Ce guide vous explique comment installer et configurer Claude Code (CLI et extension VS Code) pour la formation, en utilisant OpenRouter comme fournisseur de modèles.

## Prérequis

- **Visual Studio Code** version 1.98.0 ou supérieure : [Télécharger](https://code.visualstudio.com/)
- **Terminal** : PowerShell (Windows), bash/zsh (macOS/Linux)
- **Connexion internet**
- **Clé API OpenRouter** : Fournie par le formateur

## Installation de Claude Code

> **Chemin canonique : l'installation native.** C'est la méthode par défaut de la documentation officielle Anthropic (script d'installation, Homebrew, WinGet selon la plateforme) : Node.js n'est pas requis, le binaire vit sous `~/.local/bin` et se met à jour via `claude update`. Source consultée le 2026-09-09 : [code.claude.com/docs/en/quickstart](https://code.claude.com/docs/en/quickstart). Tout autre chemin ci-dessous est une **alternative**, à n'emprunter que si sa condition s'applique.

### Chemin canonique : Installation Native

L'installation native ne nécessite pas Node.js et fonctionne sur tous les systèmes d'exploitation.

#### Windows

1. Téléchargez l'installateur depuis [claude.com/code](https://claude.com/code)
1. Exécutez l'installateur `.exe`
1. Suivez les instructions a l'écran
1. Redémarrez votre terminal

**Verification :**

```powershell
claude --version
```

#### macOS

```bash
# Via Homebrew
brew install --cask claude-code

# Ou telechargement direct
# Telechargez le .dmg depuis claude.com/code
```

**Verification :**

```bash
claude --version
```

#### Linux / WSL

```bash
# Installation via le script officiel (binaire natif, Node.js non requis)
curl -fsSL https://claude.ai/install.sh | bash

# Si "claude --version" reste introuvable apres avoir rouvert le terminal :
# echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
```

Le binaire natif vit sous `~/.local/bin` (cf. encadré ci-dessus) et les installations natives se mettent à jour automatiquement en arrière-plan. Source consultée le 2026-09-12 : [code.claude.com/docs/en/quickstart](https://code.claude.com/docs/en/quickstart).

**Verification :**

```bash
claude --version
```

### Alternative : Installation via npm

**Condition qui sélectionne cette alternative** : votre poste interdit l'installation de binaires hors gestionnaire de paquets, ou Node.js 18+ est déjà installé et géré par votre équipe.

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

**Note :** jamais `sudo npm install -g` — si npm réclame des droits, revenez au chemin canonique (natif) ci-dessus ou configurez un préfixe utilisateur (`npm config set prefix ~/.npm-global`). L'installation native reste le chemin canonique : elle évite les conflits de versions Node.js.

## Installation de l'Extension VS Code

### Méthode 1 : Via VS Code Marketplace

1. Ouvrez **Visual Studio Code**
1. Appuyez sur `Ctrl+Shift+X` (Windows/Linux) ou `Cmd+Shift+X` (macOS)
1. Recherchez **"Claude Code"**
1. Trouvez l'extension officielle **"Claude Code" par Anthropic**
1. Cliquez sur **Installer**
1. Redémarrez VS Code si demande

### Méthode 2 : Lien Direct

Cliquez sur ce lien : [Installer Claude Code pour VS Code](vscode:extension/anthropic.claude-code)

### Méthode 3 : Command Palette

1. `Cmd+Shift+P` / `Ctrl+Shift+P`
1. Tapez : `Extensions: Install Extensions`
1. Recherchez **"Claude Code"**
1. Installez

## Configuration avec OpenRouter (couche d'accès aux modèles — distincte de l'installation)

**Condition qui sélectionne cette voie d'accès** : vous passez par OpenRouter (clé fournie par le formateur) plutôt que par un compte Anthropic direct. Ce n'est pas un second chemin d'installation : l'outil `claude` installé ci-dessus est le même, seule la couche d'accès aux modèles change. Le proxy est un script Node issu d'un dépôt Git (zéro dépendance) : Node.js est requis pour cette brique, même si Claude Code a été installé nativement.

> **Diagnostic du proxy** : vérifiez qu'il tourne avec `curl http://127.0.0.1:8899/api/v1/models` — une réponse JSON avec la liste des modèles confirme qu'il est actif. **Symptôme s'il ne tourne pas** : chaque appel modèle de Claude Code échoue avec une erreur de connexion (`fetch failed` / `connection refused`) vers `http://127.0.0.1:8899` — y compris des jours plus tard si le proxy a été lancé détaché en arrière-plan et que la machine a redémarré. Rattachez d'abord la panne au proxy avant de soupçonner votre clé ou votre installation.

### Étape 0 : Installer le proxy OpenRouter (Requis pour l'accès OpenRouter)

Les requêtes OpenRouter ne sont pas strictement compatibles avec le protocole Anthropic utilise par Claude Code (bug connu : réponses mal formatées, erreurs d'authentification intermittentes). Le proxy [openrouter-proxy](https://github.com/ahaostudy/openrouter-proxy) traduit les requêtes correctement.

**Installation :**

> **Vérifié le 2026-09-09 (#15419)** : le paquet `openrouter-proxy` **n'existe pas sur le registre npm** (`npm install -g openrouter-proxy` → 404). L'installation réelle, conforme au dépôt upstream, est un clonage Git — zéro dépendance, seul Node.js (≥ 16) est requis.

```bash
git clone https://github.com/ahaostudy/openrouter-proxy.git
```

**Lancement :**

```bash
# Lance le proxy sur le port 8899 par defaut
cd openrouter-proxy
node proxy.js
```

Le proxy doit tourner en arrière-plan tant que vous utilisez Claude Code. Verifiez qu'il fonctionne :

```bash
curl http://127.0.0.1:8899/api/v1/models
```

Une réponse JSON avec la liste des modèles confirme que le proxy est actif.

**Lancement automatique (optionnel) :**

Windows - Ajoutez a votre profil PowerShell (`notepad $PROFILE`), en adaptant le chemin du clone :

```powershell
Start-Process -WindowStyle Hidden -FilePath "node" -ArgumentList "$HOME\openrouter-proxy\proxy.js"
```

macOS / Linux - Ajoutez a `~/.zshrc` ou `~/.bashrc` :

```bash
(node ~/openrouter-proxy/proxy.js &>/dev/null &)
```

### Étape 1 : Obtenir la Clé API OpenRouter

**La clé API vous sera fournie par le formateur.** Conservez-la précieusement.

Si vous souhaitez créer votre propre compte OpenRouter :

1. Visitez [openrouter.ai](https://openrouter.ai/)
1. Créez un compte
1. Accédez a [Settings > API Keys](https://openrouter.ai/settings/keys)
1. Créez une nouvelle clé API

### Étape 2 : Configuration via fichier settings.json (Recommandée)

La méthode la plus fiable pour configurer Claude Code est le fichier `settings.json`. Contrairement aux variables d'environnement, cette méthode fonctionne dans **tous les contextes** (terminal, VS Code, scripts) sans manipuler votre profil shell.

#### Option A : Fichier machine (recommandé)

Créez ou editez le fichier de settings de votre machine :

- **Windows** : `C:\Users\<UTILISATEUR>\.claude\settings.json`
- **macOS / Linux** : `~/.claude/settings.json`

Contenu :

```json
{
  "env": {
    "ANTHROPIC_BASE_URL": "http://127.0.0.1:8899/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-or-v1-VOTRE_CLE_OPENROUTER",
    "ANTHROPIC_API_KEY": "",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "qwen/qwen3.6-plus",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "minimax/minimax-m2.7",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "qwen/qwen3.6-35b-a3b"
  }
}
```

**Pourquoi cette méthode est préférable :**

- Fonctionne immédiatement dans le terminal, VS Code et les scripts
- Pas besoin de modifier votre profil shell
- Pas besoin de redémarrer VS Code pour prendre en compte les changements
- Le fichier `~/.claude/settings.json` est propre a votre machine et ne sera jamais commite dans un depot git

#### Option B : Fichier projet (si configuration spécifique)

Créez `.claude/settings.json` a la racine du projet :

```json
{
  "env": {
    "ANTHROPIC_BASE_URL": "http://127.0.0.1:8899/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-or-v1-VOTRE_CLE_OPENROUTER",
    "ANTHROPIC_API_KEY": ""
  }
}
```

**Important :** Ajoutez-le a votre `.gitignore` pour ne pas exposer votre clé API :

```bash
echo ".claude/settings.json" >> .gitignore
```

#### Ordre de priorite des settings

Claude Code charge les configurations dans cet ordre (la dernière ecrase les precedentes) :

1. Configuration par défaut de Claude Code
1. `~/.claude/settings.json` (fichier machine)
1. `.claude/settings.json` (fichier projet)
1. Variables d'environnement (PowerShell/Bash, cf. Étape 3)

### Étape 3 : Configuration via Variables d'Environnement (Alternative)

Si vous préférez utiliser les variables d'environnement, cette méthode fonctionne également. **Choisissez l'une ou l'autre méthode, pas les deux a la fois.**

#### Windows (PowerShell)

**Configuration temporaire (session actuelle) :**

```powershell
$env:ANTHROPIC_BASE_URL = "http://127.0.0.1:8899/api"
$env:ANTHROPIC_AUTH_TOKEN = "VOTRE_CLE_OPENROUTER"
$env:ANTHROPIC_API_KEY = ""
```

**Configuration permanente (profil PowerShell) :**

Ouvrez votre profil PowerShell :

```powershell
notepad $PROFILE
```

Ajoutez les lignes suivantes :

```powershell
# ============================================
# Configuration OpenRouter pour Claude Code
# ============================================

# Configuration de base OpenRouter
$env:ANTHROPIC_BASE_URL = "http://127.0.0.1:8899/api"
$env:ANTHROPIC_AUTH_TOKEN = "sk-or-v1-VOTRE_CLE_OPENROUTER"
$env:ANTHROPIC_API_KEY = ""

# Mapping des aliases de modeles (optionnel - voir section Modeles Alternatifs)
$env:ANTHROPIC_DEFAULT_OPUS_MODEL = "qwen/qwen3.6-plus"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL = "minimax/minimax-m2.7"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL = "qwen/qwen3.6-35b-a3b"
```

Sauvegardez et rechargez :

```powershell
. $PROFILE
```

#### macOS / Linux (Zsh/Bash)

**Quel fichier editer ?** Sur macOS moderne (Catalina+), le shell par défaut est **zsh**. Selon votre configuration, editez **l'un** des fichiers suivants :

- **`~/.zshrc`** : Source pour tous les shells zsh interactifs (Terminal + VSCode). **Recommandé** - couvre tous les cas.
- **`~/.zprofile`** : Source uniquement pour les shells zsh de connexion (login). Fonctionne avec Terminal.app/iTerm2, mais **pas toujours** avec le terminal VSCode.
- **`~/.bashrc`** : Shells bash interactifs. Uniquement si vous utilisez bash (`chsh -s /bin/bash`).
- **`~/.bash_profile`** : Shells bash de connexion. Même remarque que `.zprofile` pour bash.

> **Conseil :** Si vous avez déjà un `~/.zprofile` mais pas de `~/.zshrc`, le plus simple est de créer `~/.zshrc` ou d'ajouter les exports dans votre `~/.zprofile` existant. Les deux fonctionnent depuis Terminal.app. Si vous utilisez aussi le terminal integre de VSCode, préférez `~/.zshrc`.

Pour verifier quel shell vous utilisez :

```bash
echo $SHELL    # Affiche /bin/zsh ou /bin/bash
```

Pour verifier quels fichiers de profil existent déjà :

```bash
ls -la ~/.zshrc ~/.zprofile ~/.bashrc ~/.bash_profile 2>/dev/null
```

Editez le fichier adapte (exemple avec `~/.zshrc`) :

```bash
nano ~/.zshrc    # ou: nano ~/.zprofile si c'est votre seul fichier de profil
```

Ajoutez les lignes suivantes a la fin du fichier :

```bash
# ============================================
# Configuration OpenRouter pour Claude Code
# ============================================

# Configuration de base OpenRouter
export ANTHROPIC_BASE_URL="http://127.0.0.1:8899/api"
export ANTHROPIC_AUTH_TOKEN="sk-or-v1-VOTRE_CLE_OPENROUTER"
export ANTHROPIC_API_KEY=""

# Mapping des aliases de modeles (optionnel - voir section Modeles Alternatifs)
export ANTHROPIC_DEFAULT_OPUS_MODEL="qwen/qwen3.6-plus"
export ANTHROPIC_DEFAULT_SONNET_MODEL="minimax/minimax-m2.7"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="qwen/qwen3.6-35b-a3b"
```

Rechargez le fichier (adaptez selon le fichier que vous avez modifie) :

```bash
source ~/.zshrc       # Si vous avez edite .zshrc
# ou
source ~/.zprofile    # Si vous avez edite .zprofile
```

> **Important :** Après avoir recharge, **fermez et rouvrez votre terminal** (et VSCode si vous l'utilisez) pour que les variables soient prises en compte partout. Un simple `source` ne suffit pas toujours pour les applications lancees depuis le Finder ou Spotlight.

### Étape 4 : Verification de la Configuration

#### Via CLI

```bash
claude /status
```

Vous devriez voir :

```text
Connected to OpenRouter
Model: minimax/minimax-m2.7 (sonnet alias)
Base URL: http://127.0.0.1:8899/api
```

#### Via VS Code Extension

1. Ouvrez Claude Code dans VS Code (icone ou `Cmd+Shift+P` > "Claude Code")
1. Desactivez la demande de connexion :
   - `Cmd+,` > Extensions > Claude Code
   - Activez **"Disable Login Prompt"**
1. Tapez un message de test : `Bonjour, peux-tu me confirmer que tu fonctionnes ?`

#### Tester chaque modèle

```bash
# Test du modele par defaut (Sonnet)
claude -p "Reponds juste 'OK' pour confirmer que tu fonctionnes"

# Test Opus
claude --model opus -p "Reponds 'Opus OK'"

# Test Haiku
claude --model haiku -p "Reponds 'Haiku OK'"
```

---

## Modèles Alternatifs via OpenRouter

OpenRouter permet d'utiliser des modèles alternatifs a Claude, souvent moins chers et performants pour le code.

### Pourquoi des modèles alternatifs ?

- **Coûts** : Jusqu'a 30x moins cher que les modèles Claude natifs
- **Flexibilite** : Tester différents modèles selon vos besoins
- **Experimentation** : Comparer les performances sur vos cas d'usage
- **Disponibilite** : Avoir des alternatives en cas d'indisponibilite

### Modèles Recommandes (Mars 2026)

| Alias Claude | Modèle Alternatif | Identifiant OpenRouter | Context | Prix (Input/Output per M) |
| ------------ | ----------------- | ---------------------- | ------- | ------------------------- |
| `opus` | Qwen 3.6 Plus | `qwen/qwen3.6-plus` | 262K | voir OpenRouter |
| `sonnet` | MiniMax M2.7 | `minimax/minimax-m2.7` | 205K | $0.30 / $1.20 |
| `haiku` | Qwen 3.6 35B-A3B | `qwen/qwen3.6-35b-a3b` | 262K | $0.20 / $1.56 |

### Commandes CLI

```bash
# Utiliser le modele par defaut (Sonnet -> Qwen 3.5 397B)
claude -p "Explique ce code"

# Utiliser explicitement un modele
claude --model opus -p "Refactore ce projet"    # Qwen 3.6 Plus
claude --model sonnet -p "Corrige ce bug"       # MiniMax M2.7
claude --model haiku -p "Liste les fichiers"    # Qwen 3.6 35B-A3B

# Forcer un modele specifique (bypass alias)
claude --model qwen/qwen3.6-plus -p "Question complexe"
```

### Presentation des Modèles

#### Qwen 3.6 Plus (Alias Opus)

**Identifiant :** `qwen/qwen3.6-plus`

Qwen 3.6 Plus est le modèle flagship de la famille Qwen 3.6 (Alibaba, avril 2026), plus recent et plus performant que Kimi K2.5 sur les taches de raisonnement et de coding agentique :

- **Context window** : 262K tokens
- **Forces** : Raisonnement avance, programmation complexe, taches agentiques multi-étapes
- **Cas d'usage idéaux** : Refactoring complexe, architecture de projets, documentation technique
- **Prix** : voir [openrouter.ai/qwen/qwen3.6-plus](https://openrouter.ai/qwen/qwen3.6-plus)

#### MiniMax M2.7 (Alias Sonnet)

**Identifiant :** `minimax/minimax-m2.7`

Modèle de dernière génération optimise pour la productivite et le coding :

- **Context window** : 205K tokens
- **Forces** : Coding agentique, workflows autonomes, amelioration continue, excellent sur benchmarks coding
- **Cas d'usage idéaux** : Developpement quotidien, debug, génération de tests, refactoring
- **Prix** : $0.30 / $1.20 per million tokens (input/output)

#### Qwen 3.6 35B-A3B (Alias Haiku)

**Identifiant :** `qwen/qwen3.6-35b-a3b`

Modèle dense compact et rapide :

- **Taille** : 27B paramètres (dense)
- **Context window** : 262K tokens
- **Forces** : Rapidite, bon rapport qualite/coût, coding solide pour sa taille
- **Cas d'usage idéaux** : Exploration rapide, questions simples, taches repetitives, prototypage
- **Prix** : $0.20 / $1.56 per million tokens (input/output)

### Comparaison avec les Modèles Claude Natifs

| Aspect | Claude Opus | Qwen 3.6 Plus | Claude Sonnet | MiniMax M2.7 | Claude Haiku | Qwen 3.6 35B-A3B |
| ---------------- | ----------- | ------------- | ------------- | ------------ | ------------ | ------------ |
| **Context** | 200K | 262K | 200K | 205K | 200K | 262K |
| **Prix Input** | $15.00 | voir OR | $3.00 | $0.30 | $0.25 | $0.20 |
| **Prix Output** | $75.00 | voir OR | $15.00 | $1.20 | $1.25 | $1.56 |
| **Coding** | Excellent | Excellent | Très bon | Excellent | Bon | Très bon |
| **Raisonnement** | Excellent | Excellent | Très bon | Très bon | Bon | Bon |

**Note :** Les prix sont indicatifs. Consultez [OpenRouter Models](https://openrouter.ai/models) pour les tarifs à jour.

### Dans les Subagents

Vous pouvez assigner des modèles différents aux subagents :

```json
{
  "reviewer": {
    "description": "Code reviewer",
    "model": "opus",
    "tools": ["Read", "Grep"]
  },
  "explorer": {
    "description": "Fast exploration",
    "model": "haiku",
    "tools": ["Read", "Glob"]
  }
}
```

---

## Configuration de l'Extension VS Code

### Paramètres Recommandes

1. Ouvrez les paramètres : `Cmd+,` / `Ctrl+,`
1. Allez dans **Extensions > Claude Code**
1. Configurez :

| Paramètre | Valeur Recommandée | Description |
| ------------------------- | ------------------ | ------------------------------------ |
| **Disable Login Prompt** | Active | Évite la connexion Anthropic |
| **Initial Permission Mode** | `default` | Demande avant chaque action |
| **Preferred Location** | `sidebar` | Position dans l'interface |
| **Autosave** | Active | Sauvegarde avant lecture/écriture |
| **Respect Git Ignore** | Active | Exclut les fichiers ignores |

### Raccourcis Clavier

Personnalisez vos raccourcis : `Cmd+K Cmd+S` / `Ctrl+K Ctrl+S`

**Raccourcis par défaut :**

- **Toggle Claude Code** : `Cmd+Esc` / `Ctrl+Esc`
- **New Conversation (Tab)** : `Cmd+Shift+Esc` / `Ctrl+Shift+Esc`
- **Insert @-mention** : `Alt+K`

## Configuration des MCP Servers

Les serveurs MCP etendent les capacités de Claude Code.

### Installation de Serveurs MCP Recommandes

#### 1. Serveur de Recherche Web (SearXNG)

Le MCP SearXNG requiert une instance dont le format JSON est activé (le conteneur
`searxng/searxng:latest` le désactive par défaut : `/search?...&format=json` répond
alors `403`). Lancez une instance locale :

```bash
mkdir -p searxng
cat > searxng/settings.yml << 'EOF'
use_default_settings: true
server:
  secret_key: "remplacez-par-une-chaine-aleatoire-longue"
search:
  formats:
    - html
    - json
EOF
docker run -d --name searxng -p 8181:8080 -v "$(pwd)/searxng:/etc/searxng" searxng/searxng:latest
```

> `server.secret_key` est obligatoire dès que vous montez votre propre
> `settings.yml` — sans elle, le worker SearXNG refuse de démarrer.

Puis déclarez le serveur MCP :

```bash
claude mcp add --transport http searxng http://localhost:8181/
```

Vérification : `curl 'http://localhost:8181/search?q=test&format=json'` doit
répondre `200` avec un objet JSON.

Si vous disposez d'une instance privée authentifiée (fournie par l'établissement),
remplacez l'URL locale par la sienne et ajoutez les en-têtes d'authentification
correspondants (`claude mcp add --help`) — ce n'est jamais le chemin par défaut.

#### 2. Serveur Playwright (Automatisation Navigateur)

Permet d'interagir avec des pages web, remplir des formulaires, prendre des captures d'écran.

```bash
claude mcp add --transport stdio playwright -- npx -y @anthropic/mcp-server-playwright
```

#### 3. Serveur GitHub

```bash
claude mcp add --transport http github https://api.githubcopilot.com/mcp/
```

#### 4. Context7 (Documentation à jour)

Fournit de la documentation actualisee et des exemples de code spécifiques aux versions pour vos prompts. Évite les informations obsolètes des LLMs.

```bash
claude mcp add --transport stdio context7 -- npx -y @upstash/context7-mcp
```

**Utilisation** : Ajoutez "use context7" a votre question ou précisez l'ID de la librairie.

#### 5. OpenMemory (Memoire persistante)

Permet a Claude de mémoriser le contexte entre les sessions. Plus besoin de re-expliquer votre projet a chaque nouvelle conversation.

```bash
claude mcp add --transport stdio openmemory -- npx -y @mem0/openmemory-mcp
```

**Avantages** : Memoire locale, cross-client (fonctionne avec Cursor, VS Code, etc.).

#### 6. Serena (Agent de code semantique)

Toolkit d'agent de codage offrant récupération et edition semantique via LSP. Supporte 30+ langages de programmation.

```bash
claude mcp add --transport stdio serena -- uvx --from git+https://github.com/oraios/serena serena start-mcp-server --context claude-code --project "$(pwd)"
```

**Note** : Utilisez `--context claude-code` pour éviter les conflits avec les outils natifs de Claude Code.

#### 7. QuantConnect (Trading Algorithmique - Cours partenaire)

Le serveur MCP QuantConnect permet a Claude Code d'interagir directement avec la plateforme QuantConnect : créer des projets, compiler du code, lancer des backtests, analyser les resultats. Indispensable pour le cours de trading algorithmique.

**Prérequis :**

- Un compte QuantConnect (gratuit sur [quantconnect.com](https://www.quantconnect.com/))
- Docker Desktop installe et en cours d'exécution
- Vos identifiants QC fournis par le formateur

**Configuration :**

1. Récupérez vos identifiants QuantConnect :
   - **User ID** : Trouvez-le dans [Account Settings](https://www.quantconnect.com/account)
   - **API Token** : Generez-le dans [API Credentials](https://www.quantconnect.com/account/api)
   - **Organization ID** : Visible dans [Organizations](https://www.quantconnect.com/organization)

2. Créez un fichier `.mcp.json` a la racine de votre projet :

```json
{
  "mcpServers": {
    "qc-mcp": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "QUANTCONNECT_USER_ID",
        "-e", "QUANTCONNECT_API_TOKEN",
        "-e", "QUANTCONNECT_ORGANIZATION_ID",
        "quantconnect/mcp-server"
      ],
      "env": {
        "QUANTCONNECT_USER_ID": "VOTRE_USER_ID",
        "QUANTCONNECT_API_TOKEN": "VOTRE_API_TOKEN",
        "QUANTCONNECT_ORGANIZATION_ID": "VOTRE_ORG_ID"
      }
    }
  }
}
```

**Important :** Ajoutez `.mcp.json` a votre `.gitignore` pour ne jamais exposer vos identifiants :

```bash
echo ".mcp.json" >> .gitignore
```

1. Verifiez que Docker est lance :

```bash
docker ps
```

Si Docker n'est pas lance, démarrez Docker Desktop et attendez qu'il soit pret.

1. Redémarrez Claude Code pour charger le serveur MCP :

```bash
# Dans VS Code : fermez et rouvrez le panneau Claude Code
# Ou en CLI : relancez votre session claude
```

1. Verifiez la connexion dans Claude Code :

```text
/mcp
```

Vous devriez voir le serveur `qc-mcp` avec le statut "Connected" et environ 60 outils disponibles.

**Cas d'usage typiques avec Claude Code + QuantConnect :**

```text
> Cree un projet QuantConnect Python appele "Mon-Strategy" avec une strategie EMA cross

> Compile le projet actuel et dis-moi s'il y a des erreurs

> Lance un backtest sur le projet avec les dates 2023-01-01 a 2024-12-31

> Analyse les resultats du dernier backtest : Sharpe, CAGR, Max Drawdown
```

**Resolution de problèmes :**

| Problème | Solution |
| ---------- | ---------- |
| "Docker not found" | Installez Docker Desktop et redémarrez votre terminal |
| "Authentication failed" | Verifiez vos identifiants dans `.mcp.json` |
| "No spare nodes" | Attendez quelques minutes, les ressources QC sont partagees |
| Rate limiting | Max 10 appels/minute. Postez sur le dashboard si blocage persistant |

### Gestion des Serveurs MCP

**Lister les serveurs configures :**

```bash
claude mcp list
```

**Voir les détails d'un serveur :**

```bash
claude mcp get searxng
```

**Supprimer un serveur :**

```bash
claude mcp remove searxng
```

**Verifier le statut (dans Claude Code) :**

```text
/mcp
```

### Configuration par Portee (Scope)

**Serveur personnel (utilisateur) :**

```bash
claude mcp add --transport http --scope user mon-serveur https://...
```

**Serveur partage (projet - versionne) :**

```bash
claude mcp add --transport http --scope project mon-serveur https://...
```

Créera un fichier `.mcp.json` dans votre projet.

## Premiers Pas

### Test CLI

**Session interactive de base :**

```bash
claude
```

**Poser une question :**

```text
> Explique-moi la structure de ce projet
```

**Query ponctuelle :**

```bash
claude -p "Liste les fichiers Python de ce projet"
```

**Continuer la dernière conversation :**

```bash
claude -c
```

### Test Extension VS Code

1. **Ouvrir un fichier dans VS Code**
1. **Cliquer sur l'icone (spark)** dans la barre d'outils
1. **Selectionner du code**
1. **Appuyer sur `Alt+K`** pour créer une référence
1. **Poser une question :** `Explique-moi ce code`
1. **Examiner la réponse et les diffs proposes**

### Générer CLAUDE.md pour Votre Projet

```bash
cd /chemin/vers/votre/projet
claude
```

Puis dans Claude :

```text
/init
```

Claude générera automatiquement un fichier `CLAUDE.md` adapte a votre projet.

## Resolution de Problèmes

### Problème : "Command not found: claude"

**Solution :**

- Verifiez l'installation : `which claude` (macOS/Linux) ou `where.exe claude` (Windows)
- Ajoutez au PATH si nécessaire
- Redémarrez votre terminal

### Problème : "Authentication failed" avec OpenRouter

**Solution :**

Verifiez que les variables d'environnement sont bien definies :

```bash
echo $ANTHROPIC_BASE_URL       # Doit afficher http://127.0.0.1:8899/api
echo $ANTHROPIC_AUTH_TOKEN     # Doit afficher votre cle sk-or-v1-...
echo $ANTHROPIC_API_KEY        # Doit afficher une ligne vide
```

Verifiez votre clé API sur [openrouter.ai/settings/keys](https://openrouter.ai/settings/keys).

Sur macOS, verifiez que les exports sont dans le bon fichier de profil (voir Étape 3).

### Problème : Extension VS Code ne se connecte pas

**Solution :**

1. Activez **"Disable Login Prompt"** dans les paramètres
1. Redémarrez VS Code **complètement** (pas juste recharger la fenetre)
1. Verifiez les logs : `Cmd+Shift+P` > "Developer: Show Logs"

### Problème : "Model not found"

Verifiez que l'identifiant du modèle est correct sur [OpenRouter Models](https://openrouter.ai/models).

### Problème : "Rate limit exceeded"

1. Attendez quelques secondes et reessayez
1. Verifiez vos credits sur [OpenRouter Activity](https://openrouter.ai/activity)
1. Considerez un plan payant pour des limites plus élevées

### Problème : Le modèle ne repond pas comme attendu

Certains modèles alternatifs ont des comportements différents. Ajustez vos prompts :

```bash
# Etre plus explicite sur le format attendu
claude -p "Reponds UNIQUEMENT avec du code Python, sans explication"

# Specifier le contexte
claude -p "En tant qu'expert Python, analyse ce code : ..."
```

### Problème : MCP server ne repond pas (Windows)

Pour les serveurs locaux `npx` sur Windows, utilisez le wrapper `cmd /c` :

```bash
claude mcp add --transport stdio mon-serveur -- cmd /c npx -y @package/nom
```

## Commandes Utiles

**Mettre à jour Claude Code :**

```bash
claude update
```

**Afficher l'aide :**

```bash
claude --help
```

**Afficher la version :**

```bash
claude --version
```

**Mode debug :**

```bash
claude --debug
```

**Desactiver la persistance de session :**

```bash
claude -p --no-session-persistence "query"
```

## Configuration Avancee

### Personnalisation du System Prompt

**Ajouter des instructions globales :**

```bash
claude --append-system-prompt "Toujours utiliser TypeScript et inclure des tests"
```

**Remplacer complètement le system prompt :**

```bash
claude --system-prompt "Tu es un expert Python specialise en data science"
```

### Définir des Agents Personnalises

Créez un fichier `custom-agents.json` :

```json
{
  "reviewer": {
    "description": "Expert en revue de code. Utiliser apres modifications.",
    "prompt": "Tu es un senior code reviewer. Concentre-toi sur qualite, securite et best practices.",
    "tools": ["Read", "Grep", "Glob"],
    "model": "sonnet"
  },
  "tester": {
    "description": "Specialiste des tests. Utiliser pour debugging.",
    "prompt": "Tu es un expert en tests et debugging. Analyse les erreurs et propose des fixes."
  }
}
```

Utilisez-le :

```bash
claude --agents @custom-agents.json
```

### Configuration des Permissions

Editez `.claude/settings.json` :

```json
{
  "permissionMode": "default",
  "allowedTools": [
    "Read",
    "Glob",
    "Grep",
    "Bash(git log:*)",
    "Bash(git diff:*)",
    "Bash(git status:*)"
  ],
  "disallowedTools": [
    "Write(/etc/*:*)",
    "Bash(rm:*)"
  ]
}
```

---

## Ressources

### Documentation Officielle

- [Quickstart](https://code.claude.com/docs/en/quickstart)
- [CLI Reference](https://code.claude.com/docs/en/cli-reference)
- [VS Code Documentation](https://code.claude.com/docs/en/vs-code)
- [MCP Guide](https://code.claude.com/docs/en/mcp)

### OpenRouter

- [Documentation OpenRouter](https://openrouter.ai/docs)
- [Guide d'integration Claude Code](https://openrouter.ai/docs/guides/claude-code-integration)
- [Tarifs et modèles](https://openrouter.ai/models)
- [Qwen 3.6 Plus sur OpenRouter](https://openrouter.ai/qwen/qwen3.6-plus)
- [MiniMax M2.7 sur OpenRouter](https://openrouter.ai/minimax/minimax-m2.7)
- [Qwen 3.6 35B-A3B sur OpenRouter](https://openrouter.ai/qwen/qwen3.6-35b-a3b)

### Communaute

- [GitHub - Claude Code](https://github.com/anthropics/claude-code)
- [Awesome Claude Code](https://github.com/hesreallyhim/awesome-claude-code)
- [SkillsMP Marketplace](https://skillsmp.com/)

---

## Checklist d'Installation

- [ ] Claude Code CLI installe et fonctionnel (`claude --version`)
- [ ] Extension VS Code installee
- [ ] Fichier settings.json configure (ou variables d'environnement)
- [ ] Test CLI réussi (`claude /status`)
- [ ] Test Extension VS Code réussi
- [ ] Au moins 1 serveur MCP configure
- [ ] Fichier CLAUDE.md généré pour votre projet (`/init`)
- [ ] Raccourcis clavier personnalises (optionnel)
- [ ] Modèles alternatifs configures (optionnel)

---

*Pour decouvrir les concepts et cas d'usage, consultez [INTRO-CLAUDE-CODE.md](./INTRO-CLAUDE-CODE.md)*

*Pour approfondir Skills, Subagents, Hooks et MCP, consultez [CONCEPTS-AVANCES.md](./CONCEPTS-AVANCES.md)*