Intermédiaire 11 minIDE

IntelliJ et JetBrains + Ollama : l'assistant IA local dans son IDE

Coupler IntelliJ (ou PyCharm, WebStorm, GoLand…) à Ollama, c'est retrouver un assistant de code façon Copilot, mais qui tourne sur votre machine : chat sur votre projet, complétion en fin de ligne, refactoring — sans qu'une seule ligne ne parte vers un serveur tiers. Ce guide fait le tri entre les plugins compatibles Ollama, montre comment brancher le tout via un « proxy AI », et indique quels modèles de code choisir selon votre carte graphique.

Par Thomas P.·Màj 2026-08-11·Testé sur Windows, macOS, Linux

#Pourquoi un LLM local dans son IDE

Les assistants cloud (GitHub Copilot, JetBrains AI, Cursor) sont pratiques mais envoient le contexte de votre code — parfois le fichier entier, parfois tout le dépôt — sur des serveurs distants. Pour du code sous NDA, du logiciel propriétaire ou simplement par principe, c'est rédhibitoire. Un LLM local branché sur IntelliJ règle le problème à la racine : le modèle tourne sur votre GPU, le prompt et la complétion ne quittent jamais la machine.

L'autre argument est le coût. Un abonnement Copilot ou JetBrains AI se paie au mois, indéfiniment. Une fois Ollama installé et un modèle de code téléchargé, vous complétez et discutez sans quota, sans facturation au jeton, hors-ligne compris. Le compromis se situe sur la qualité : un modèle 7B local n'égale pas GPT-4, mais un Qwen2.5-Coder 14B ou 32B s'en approche pour la complétion et le chat courant.

Confidentialité
Le code, les prompts et les réponses restent en local. Rien n'est journalisé côté cloud.
Zéro abonnement
Aucun coût récurrent une fois le modèle téléchargé. Utilisation illimitée.
Hors-ligne
Fonctionne dans le train, sur un réseau isolé ou derrière un proxy d'entreprise strict.
Contrôle du modèle
Vous choisissez la taille, la quantification et pouvez changer de modèle selon la tâche.

#Les plugins JetBrains qui parlent à Ollama

L'écosystème JetBrains n'a pas de support natif d'Ollama universel : on passe par un plugin de la marketplace. Trois options couvrent la quasi-totalité des besoins, chacune avec un point fort différent.

ProxyAI (ex-CodeGPT)
Le plus complet côté local. Chat, complétion en ligne, edit de sélection, et un connecteur Ollama intégré. C'est le « proxy AI » évoqué dans le titre : il fait le pont entre l'IDE et le daemon Ollama.
Continue
Open source, très configurable via un fichier de config. Chat, autocomplétion et actions sur le code, provider Ollama de première classe. Idéal si vous voulez régler finement chaque modèle.
JetBrains AI Assistant
L'assistant officiel de JetBrains. Depuis 2025 il sait pointer vers un modèle local Ollama ou LM Studio pour le mode hors-ligne. Pratique si vous voulez rester dans l'outil maison, mais moins souple sur la complétion locale.
i
Un daemon, plusieurs clients
Tous ces plugins se branchent sur le même endpoint Ollama (http://localhost:11434). Vous pouvez en installer deux en parallèle — par exemple ProxyAI pour le chat et Continue pour la complétion — tant qu'ils visent le même serveur. Le modèle n'est chargé qu'une fois en VRAM par Ollama.

#Prérequis

On suppose Ollama déjà installé et fonctionnel. Le reste tient en un IDE JetBrains récent et au moins un modèle de code téléchargé.

Un IDE JetBrains 2024.1+
IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, PhpStorm… Les plugins ci-dessus s'installent sur toute la gamme depuis la même marketplace.
Ollama fonctionnel
Le daemon installé et joignable sur http://localhost:11434. Testez avec ollama list avant de configurer quoi que ce soit.
Un modèle de chat/code
qwen2.5-coder:7b est un bon point de départ polyvalent. En Q4_K_M il tient dans ~5 Go de VRAM.
Un GPU conseillé
La complétion doit répondre en moins d'une seconde pour être utile. Un RTX 3060 12 Go fait tourner un 7B confortablement ; sans GPU, réservez-vous au chat, pas à l'autocomplétion.
Terminal — préparer Ollama
# Vérifier que le daemon répond
ollama list

# Modèle de code polyvalent (chat + edit)
ollama pull qwen2.5-coder:7b

# Tester l'API que les plugins vont utiliser
curl http://localhost:11434/api/tags

#Configurer ProxyAI + Ollama

ProxyAI (anciennement CodeGPT) est le chemin le plus court vers un assistant local complet dans JetBrains. Son connecteur Ollama gère le chat, l'edit de sélection et la complétion, sans clé d'API ni compte.

  1. 01
    Installer le plugin
    Settings → Plugins → Marketplace, cherchez « ProxyAI » (ou « CodeGPT » selon la version) et installez-le. Redémarrez l'IDE si demandé.
  2. 02
    Choisir le fournisseur Ollama
    Settings → Tools → ProxyAI → Providers. Sélectionnez Ollama (Local) comme fournisseur, plutôt que les options cloud (OpenAI, Anthropic…).
  3. 03
    Vérifier l'URL du serveur
    Le champ Base URL doit pointer sur http://localhost:11434. Si Ollama tourne sur une autre machine du réseau, mettez son IP à la place de localhost.
  4. 04
    Sélectionner le modèle
    Dans la liste des modèles, choisissez celui que vous avez téléchargé (par ex. qwen2.5-coder:7b). ProxyAI interroge Ollama pour lister les modèles disponibles.
  5. 05
    Tester le chat
    Ouvrez le panneau ProxyAI (icône dans la barre latérale), posez une question sur un fichier ouvert. La réponse doit arriver en local, sans avertissement de connexion externe.
→
Ajouter du contexte au chat
Sélectionnez du code avant d'ouvrir le chat, ou utilisez la commande d'ajout de fichier au contexte : le modèle répond alors sur votre code précis plutôt que dans le vide. Les petits modèles ont une fenêtre de contexte limitée — n'y jetez pas tout le projet d'un coup, ciblez les fichiers pertinents.

#Continue et l'AI Assistant natif

Si vous préférez régler chaque détail, Continue expose sa configuration dans un fichier plutôt que dans des menus. On y déclare explicitement le provider Ollama, le modèle de chat et — séparément — le modèle de complétion. C'est plus verbeux mais bien plus précis, notamment pour attribuer un petit modèle rapide à l'autocomplétion et un plus gros au chat.

Continue — config.json (extrait)
{
  "models": [
    {
      "title": "Qwen Coder 14B",
      "provider": "ollama",
      "model": "qwen2.5-coder:14b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Autocomplete",
    "provider": "ollama",
    "model": "qwen2.5-coder:1.5b-base",
    "apiBase": "http://localhost:11434"
  }
}

Côté JetBrains AI Assistant, la marche à suivre est plus encadrée : dans les réglages de l'assistant, activez l'usage de modèles locaux et pointez vers Ollama. C'est utile pour garder un seul outil, mais l'assistant natif reste avant tout pensé pour le cloud JetBrains ; sa complétion locale est moins mûre que celle de ProxyAI ou Continue. Pour un usage 100 % local sérieux, on recommande plutôt ces deux derniers.

#Quels modèles de code selon sa VRAM

La règle est simple : plus le modèle est gros, meilleures sont ses réponses, mais plus il consomme de VRAM et plus il répond lentement. La famille Qwen2.5-Coder couvre toute la gamme et fait référence en 2026 pour le code local ; DeepSeek-Coder-V2 et CodeGemma sont de bonnes alternatives. Voici les repères en quantification Q4_K_M (le meilleur compromis taille/qualité).

Chat 3B — ~2 Go VRAM
qwen2.5-coder:3b. Dépannage rapide, questions simples. Tourne même sur un petit GPU ou en CPU pour du non-interactif.
Polyvalent 7B — ~5 Go VRAM
qwen2.5-coder:7b. Le point d'équilibre : chat, edit et refactoring corrects. Cible d'un RTX 3060 12 Go / 4070 12 Go.
Confort 14B — ~9 Go VRAM
qwen2.5-coder:14b. Nettement meilleur sur le raisonnement et les refactorings multi-fichiers. À l'aise sur un RTX 4080 16 Go.
Haut de gamme 32B — ~19 Go VRAM
qwen2.5-coder:32b. Le plus proche du cloud pour le code local. Demande un RTX 4090 24 Go ou un Mac Apple Silicon 32 Go+ de mémoire unifiée.
i
Deux modèles, deux rôles
Le chat tolère la latence ; la complétion non. On sépare donc souvent les rôles : un modèle costaud (14B/32B) pour le chat et l'edit, et un petit modèle base (1.5B/3B) pour l'autocomplétion en frappe. Ollama garde les deux en mémoire tant qu'ils tiennent dans la VRAM.

#Complétion locale : attention au FIM

La complétion façon Copilot repose sur le « fill-in-the-middle » (FIM) : le modèle doit compléter au milieu du code, en connaissant ce qui précède ET ce qui suit le curseur. Tous les modèles ne le supportent pas. Les variantes instruct sont entraînées pour le chat, pas pour le FIM — pour l'autocomplétion, utilisez les variantes base, spécifiquement conçues pour ça.

Terminal — modèles de complétion (base = FIM)
# Petit modèle base pour l'autocomplétion rapide
ollama pull qwen2.5-coder:1.5b-base

# Alternatives éprouvées pour le FIM
ollama pull starcoder2:3b
ollama pull codegemma:2b
Modèle base, pas instruct
Pour la complétion, choisissez qwen2.5-coder:1.5b-base ou 3b-base. Un modèle instruct produira des complétions bavardes ou hors format.
Petit et rapide
En autocomplétion, la vitesse prime sur la finesse. Un 1.5B qui répond en 200 ms est plus utile qu'un 14B qui met 2 secondes.
GPU quasi obligatoire
Sans accélération matérielle, la complétion arrive trop tard pour suivre la frappe. Réservez alors l'IA locale au chat.
!
Complétion lente ou incohérente ?
Deux causes classiques : un modèle instruct utilisé là où il faut un modèle base (le FIM échoue), ou un modèle trop gros pour le GPU qui déborde sur le CPU. Vérifiez le tag du modèle (-base) et surveillez la VRAM avec nvidia-smi pendant que vous tapez.

#Ce que l'IA locale ne fait pas encore dans l'IDE

Le local a progressé, mais il reste des écarts avec les assistants cloud haut de gamme. Autant les connaître pour caler ses attentes plutôt que d'être déçu.

Le raisonnement multi-fichiers
Les gros dépôts dépassent la fenêtre de contexte des modèles locaux. Le modèle voit les fichiers que vous lui donnez, pas votre architecture entière. Copilot Workspace ou Cursor indexent tout le projet ; en local, c'est encore artisanal.
Les modes agent avancés
Faire exécuter des commandes, lancer des tests et itérer en boucle (à la Cline/Cursor Agent) demande un modèle qui gère le tool-use de façon fiable. Les 7B locaux y échouent souvent ; il faut viser 14B+ et accepter des ratés.
La qualité brute sur le code complexe
Sur de l'algorithmique pointue ou des frameworks récents peu représentés à l'entraînement, un modèle local 7B-14B reste en retrait d'un GPT-4 ou Claude.
L'intégration produit fine
Détection automatique du langage, actions contextuelles nombreuses, résolution de PR… l'outillage local rattrape mais reste un cran derrière l'expérience polie des assistants commerciaux.

En pratique, le local excelle sur la complétion, le chat sur un fichier, l'explication de code et le refactoring localisé. Pour l'agentique lourde et l'analyse d'un dépôt entier, le cloud garde l'avantage — d'où l'intérêt de garder les deux et de router selon la sensibilité du code.

#Dépannage

Le plugin ne liste aucun modèle
Il n'atteint pas Ollama. Vérifiez que le daemon tourne (ollama list) et que l'URL est bien http://localhost:11434. Si Ollama est sur une autre machine, lancez-le avec OLLAMA_HOST=0.0.0.0 et pointez sur son IP.
« Connection refused »
Ollama n'est pas démarré, ou un pare-feu bloque le port 11434. Testez avec curl http://localhost:11434/api/tags depuis la même machine que l'IDE.
Le modèle n'apparaît pas dans la liste
Le tag ne correspond pas. Copiez le nom exact renvoyé par ollama list, tag inclus (qwen2.5-coder:7b et non qwen2.5-coder).
Réponses très lentes
Le modèle déborde sur le CPU. Passez à une taille inférieure ou à Q4_K_M, et vérifiez avec nvidia-smi que le GPU est bien utilisé.
Complétion vide ou absurde
Vous utilisez un modèle instruct pour le FIM. Basculez sur une variante -base (qwen2.5-coder:1.5b-base).
L'IDE rame pendant la génération
Deux modèles chargés saturent la VRAM. Réduisez la taille de l'un, ou n'activez qu'un plugin à la fois.

#Pour aller plus loin

L'assistant local dans l'IDE ne vaut que par le daemon et le GPU qui le portent. Ces guides complètent la mise en place.

Installer Ollama
La base : installer et démarrer le daemon qui sert vos modèles de code sur le port 11434.
Copilot gratuit en local : Cline, Tabby & CodeGeeX dans VS Code
L'équivalent côté VS Code, pour comparer les approches et les plugins d'un éditeur à l'autre.
Utiliser Ollama dans Claude Code et Cursor
Pour brancher les mêmes modèles locaux dans d'autres assistants et arbitrer entre local et cloud selon la tâche.
Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.