---
title: "Utiliser un modèle Ollama Cloud dans VS Code : le guide complet"
subtitle: "Installer l’extension officielle, connecter gpt-oss:120b-cloud et comprendre pourquoi localhost ne signifie pas que le modèle tourne en local"
date: 2026-09-27
time: "00:23"
author: Codex + VFG
publishedBy: cursor
status: pub
tags: ["ollama", "ollama-cloud", "vscode", "gpt-oss", "configuration-ia", "tutoriel", "windows", "base-de-connaissances"]
---

## Le point essentiel en une phrase

Un modèle nommé `gpt-oss:120b-cloud` est bien exécuté dans **Ollama Cloud**, même lorsque VS Code se connecte à `http://127.0.0.1:11434`.

Cette adresse locale n’est pas la machine qui calcule le modèle. Elle correspond au service Ollama installé sur Windows, qui sert de passerelle authentifiée entre VS Code et `ollama.com` :

```text
VS Code
  └─ extension officielle Ollama
       └─ http://127.0.0.1:11434 (passerelle locale)
            └─ https://ollama.com (inférence distante)
                 └─ gpt-oss:120b-cloud
```

C’est la confusion la plus fréquente de cette installation : **endpoint local ne veut pas dire modèle local**. Le client, l’API et la session sont locaux ; les poids du modèle et le calcul restent dans le cloud.

## Résultat obtenu et vérifié

La configuration documentée ici a été testée le 15 septembre 2026 sur Windows avec :

| Composant | Version ou valeur vérifiée |
|---|---|
| Visual Studio Code | `1.137.0` |
| Ollama | `0.32.5` |
| Extension officielle | `ollama.ollama` `0.0.9` |
| Modèle | `gpt-oss:120b-cloud` |
| Modèle distant réel | `gpt-oss:120b` |
| Hôte distant déclaré | `https://ollama.com` |
| Contexte annoncé | 131 072 tokens |
| Capacités annoncées | génération, outils, raisonnement |

Une génération de contrôle a répondu correctement depuis la ligne de commande. La session Ollama Cloud était donc authentifiée et le routage distant fonctionnel.

## Prérequis

Il faut :

- Windows avec Visual Studio Code récent ;
- Ollama installé et lancé ;
- un compte Ollama autorisé à utiliser les modèles Cloud ;
- l’extension officielle **Ollama**, publiée par **Ollama** ;
- une connexion Internet pour l’inférence distante.

Cette méthode ne nécessite pas d’installer localement les poids du modèle de la famille 120B. L’entrée Cloud visible dans `ollama list` est un petit manifeste de routage, pas une copie des poids.

## Étape 1 — Vérifier quel IDE est réellement lancé

Sur une machine qui possède VS Code et Cursor, la commande `code` peut pointer vers Cursor. C’était précisément le cas pendant cette installation.

Dans PowerShell :

```powershell
Get-Command code | Format-List Source,Path
code --version
```

Si le chemin contient `cursor`, les extensions installées avec `code --install-extension` iront dans le profil Cursor. Pour cibler explicitement VS Code installé pour l’utilisateur :

```powershell
$vscode = "$env:LOCALAPPDATA\Programs\Microsoft VS Code\bin\code.cmd"
& $vscode --version
```

Ce détail explique beaucoup de situations où « l’extension est installée » dans le terminal mais reste absente de VS Code.

## Étape 2 — Installer ou mettre à jour Ollama

Vérifier la présence du client :

```powershell
ollama --version
```

Ollama doit également être démarré. Quand le service répond, cette commande affiche les modèles connus :

```powershell
ollama list
```

Si la commande ne peut pas joindre le serveur, lancer l’application **Ollama** depuis le menu Démarrer, puis réessayer.

## Étape 3 — Se connecter à Ollama Cloud

La connexion se fait depuis le client Ollama :

```powershell
ollama signin
```

Suivre le flux d’authentification dans le navigateur. Aucun secret Ollama ne doit être copié dans `settings.json`, dans un dépôt Git ou dans une commande conservée par l’historique du terminal.

Ensuite, enregistrer le modèle Cloud souhaité :

```powershell
ollama pull gpt-oss:120b-cloud
```

Le mot-clé `:cloud` est déterminant. Sans lui, on peut sélectionner une variante locale différente et déclencher le téléchargement de poids sur la machine.

## Étape 4 — Installer l’extension officielle dans le vrai VS Code

Depuis l’interface :

1. Ouvrir **Extensions** avec `Ctrl+Shift+X`.
2. Chercher **Ollama**.
3. Vérifier que l’éditeur est **Ollama**.
4. Installer l’extension.

Ou depuis PowerShell, en ciblant sans ambiguïté VS Code :

```powershell
$vscode = "$env:LOCALAPPDATA\Programs\Microsoft VS Code\bin\code.cmd"
& $vscode --install-extension ollama.ollama
```

Vérification :

```powershell
& $vscode --list-extensions --show-versions |
  Select-String '^ollama\.ollama@'
```

## Étape 5 — Configurer la passerelle Ollama

Ouvrir les paramètres JSON utilisateur de VS Code avec la commande **Preferences: Open User Settings (JSON)**, puis ajouter :

```json
{
  "ollama.endpoint": "http://127.0.0.1:11434"
}
```

Si le fichier contient déjà d’autres réglages, ajouter seulement cette propriété en respectant les virgules du JSON.

`ollama.endpoint` indique où l’extension trouve le service Ollama. La sélection explicite de `gpt-oss:120b-cloud` dans le sélecteur reste obligatoire pour garantir la variante Cloud : un réglage de modèle limité à la famille `gpt-oss` ne suffit pas à distinguer toutes ses variantes. Une conversation déjà ouverte peut conserver son ancien modèle ; il faut alors ouvrir une nouvelle conversation ou changer de modèle manuellement.

Le réglage n’envoie pas directement les requêtes à `ollama.com`. La session Cloud reste gérée par Ollama, ce qui évite de stocker une clé dans VS Code.

## Étape 6 — Sélectionner le modèle dans le chat

1. Redémarrer ou recharger VS Code après l’installation de l’extension.
2. Ouvrir le chat avec `Ctrl+Alt+I`.
3. Ouvrir le sélecteur de modèle en bas de la zone de saisie.
4. Chercher la section **Ollama**.
5. Choisir `gpt-oss:120b-cloud`.

Dans une fenêtre en mode restreint, VS Code peut masquer des modèles. Vérifier alors que le workspace est approuvé avant de conclure à un problème Ollama.

## Étape 7 — Prouver que le modèle est réellement Cloud

### Contrôle rapide avec `ollama list`

```powershell
ollama list
```

L’entrée doit porter explicitement le suffixe `:cloud`. Sa taille locale est minuscule comparée à un véritable modèle de 120 milliards de paramètres.

### Contrôle détaillé par l’API locale

```powershell
Invoke-RestMethod `
  -Uri 'http://127.0.0.1:11434/api/tags' `
  -Method Get |
  ConvertTo-Json -Depth 6
```

Pour le modèle testé, la réponse contient notamment :

```json
{
  "name": "gpt-oss:120b-cloud",
  "remote_model": "gpt-oss:120b",
  "remote_host": "https://ollama.com",
  "size": 307
}
```

`remote_host` constitue la preuve la plus claire : le service local connaît un modèle hébergé sur `ollama.com`. La valeur `size` correspond au manifeste local, pas à la taille du modèle distant.

### Contrôle par une génération

```powershell
ollama run gpt-oss:120b-cloud "Réponds uniquement par OK."
```

Une réponse valide confirme trois éléments à la fois : le service local répond, la session Cloud est utilisable et le modèle distant accepte les requêtes.

## Diagnostic des problèmes courants

### Le modèle n’apparaît pas dans VS Code

Vérifier dans cet ordre :

1. `ollama list` contient bien `gpt-oss:120b-cloud` ;
2. `http://127.0.0.1:11434/api/tags` répond ;
3. l’extension `ollama.ollama` est installée dans **VS Code**, pas seulement dans Cursor ;
4. le workspace est approuvé ;
5. exécuter **Ollama: Refresh Models** dans la palette de commandes ;
6. exécuter **Ollama: Diagnose Models** et lire le canal de sortie **Ollama**.

### Ollama demande de se reconnecter

Relancer :

```powershell
ollama signin
```

Puis tester directement le modèle avec `ollama run`. Si la ligne de commande échoue également, le problème se situe avant VS Code.

### `127.0.0.1` donne l’impression que tout tourne localement

C’est normal : VS Code parle au client local. Pour déterminer où le calcul est exécuté, regarder le nom `:cloud` et les champs `remote_host` et `remote_model` de `/api/tags`.

### La commande `code` modifie le mauvais IDE

Utiliser le chemin complet de `code.cmd` fourni avec Visual Studio Code. Les profils d’extensions de VS Code et Cursor sont séparés :

```text
%USERPROFILE%\.vscode\extensions   → Visual Studio Code
%USERPROFILE%\.cursor\extensions   → Cursor
```

### Le modèle répond dans le terminal mais pas dans le chat

Recharger la fenêtre avec **Developer: Reload Window**, rafraîchir les modèles Ollama, puis ouvrir une nouvelle conversation. Le choix d’un ancien fil de discussion peut rester mémorisé indépendamment du modèle par défaut.

## Ce que cette intégration permet — et ce qu’elle ne remplace pas

Le modèle fourni par l’extension Ollama peut alimenter le chat VS Code. Les workflows agentiques sont disponibles lorsque le modèle expose les capacités nécessaires ; dans la fenêtre **Agents** séparée, le pont expérimental pour les modèles externes doit également être activé avec `chat.agentHost.byokModels.enabled`.

La documentation VS Code précise que ces modèles de chat externes peuvent être utilisés sans connexion GitHub ni abonnement Copilot. L’authentification de ce tutoriel reste toutefois celle du compte Ollama via `ollama signin` : aucune clé n’est saisie dans VS Code.

En revanche, utiliser Ollama pour le chat ne remplace pas automatiquement tous les services de l’IDE. Certaines fonctions, notamment les suggestions de code en ligne, la recherche sémantique ou les embeddings, peuvent continuer à dépendre d’une extension et d’un fournisseur distincts.

## Sécurité et exploitation

- Ne jamais placer de mot de passe ou de jeton dans les réglages versionnés du workspace.
- Préférer `ollama signin` à un secret copié dans `settings.json`.
- Vérifier le modèle sélectionné avant d’envoyer du code confidentiel : un modèle Cloud implique un traitement distant.
- Contrôler les limites, la facturation et la politique de conservation associées au compte Ollama utilisé.
- Garder Ollama et l’extension VS Code à jour, car les métadonnées de capacités et le support des modèles Cloud évoluent.

## Checklist finale

- [ ] `ollama --version` fonctionne.
- [ ] `ollama signin` a été effectué.
- [ ] `ollama list` affiche `gpt-oss:120b-cloud`.
- [ ] L’extension officielle `ollama.ollama` est installée dans VS Code.
- [ ] `ollama.endpoint` vaut `http://127.0.0.1:11434`.
- [ ] Le sélecteur de chat affiche le modèle sous **Ollama**.
- [ ] `/api/tags` indique `remote_host: https://ollama.com`.
- [ ] Une génération de test réussit.

## Références

- [Ollama Cloud — connexion, pull, exécution et accès API](https://docs.ollama.com/cloud)
- [Extension officielle Ollama pour VS Code — installation et diagnostic](https://github.com/ollama/ollama-vscode/blob/main/README.md)
- [Documentation VS Code — modèles de langage](https://code.visualstudio.com/docs/agent-customization/language-models)
- [VS Code — configuration de la fenêtre Agents](https://code.visualstudio.com/docs/agents/run/agents-window-configuration)

## Reprise et diagnostic rapide

La machine testée est prête : VS Code utilise l’extension officielle, la passerelle répond sur le port `11434`, le manifeste `gpt-oss:120b-cloud` pointe vers `https://ollama.com` et une génération distante a été validée. Pour reprendre plus tard, commencer par `ollama list`, puis `/api/tags`, puis **Ollama: Diagnose Models** dans VS Code. Cette séquence localise rapidement la panne sans confondre passerelle locale et calcul Cloud.