Coder avec une IA en local : Cline, Ollama et les assistants souverains

Les assistants de code dans le cloud sont impressionnants, mais ils ont trois défauts qui pèsent vite : ils se paient au token, ils envoient votre code sur les serveurs d’un tiers, et ils s’arrêtent dès que la connexion flanche. Pour beaucoup de développeurs — indépendants soucieux de leurs coûts, professionnels tenus à la confidentialité, curieux qui veulent comprendre — il existe une autre voie : un agent de code qui tourne entièrement sur votre machine, gratuitement et hors-ligne. Ce montage repose sur deux outils open source, Cline et Ollama. Ce guide explique pourquoi et comment les assembler, et trace un parcours d’apprentissage complet, du premier modèle téléchargé jusqu’à un agent outillé et sécurisé.

Sommaire

• Ce que ce parcours vous permettra de faire
• Le parcours d’apprentissage, étape par étape
• Pourquoi coder en local en 2026
• Les trois briques du montage
• Agent ou autocomplétion : deux outils différents
• Local ou cloud : le comparatif honnête
• Le matériel : ce qu’il faut vraiment
• Les tutoriels du parcours
• Erreurs fréquentes
• Questions fréquentes

🎯 Ce que ce parcours vous permettra de faire

• Installer un moteur d’inférence local et y faire tourner un modèle spécialisé dans le code ;
• Brancher l’agent Cline sur ce modèle pour coder sans clé API ni cloud ;
• Piloter l’agent avec méthode (modes Plan et Act, contexte, garde-fous) ;
• Choisir le bon modèle selon votre matériel et vos tâches ;
• Étendre l’agent avec des outils via MCP, et sécuriser l’ensemble.

Chaque compétence se construit sur un projet fil rouge concret — une petite application de prise de notes en ligne de commande, « carnet », écrite pas à pas par l’agent local sous votre supervision.

🗺️ Le parcours d’apprentissage, étape par étape

Les tutoriels se suivent dans l’ordre, chacun s’appuyant sur le précédent.

1. Installer Ollama et un modèle de code. Le moteur local : installation, choix selon le matériel, premier test. Commencer ici.
2. Installer Cline et le brancher sur Ollama. L’agent dans VS Code, relié au modèle local, première tâche. Suivre ce tutoriel.
3. Piloter l’agent : Plan et Act. La méthode pour garder le contrôle. Apprendre à piloter.
4. Choisir le bon modèle local. Adapter taille, type et vitesse à votre machine. Bien choisir son modèle.
5. Étendre Cline avec MCP. Donner des outils à l’agent. Outiller l’agent.
6. Sécuriser l’agent. Approbations, secrets, périmètre, garde-fous. Sécuriser le montage.

Pourquoi coder en local en 2026

Trois arguments font basculer de plus en plus de développeurs vers le local. Le premier est le coût. Un assistant cloud facture chaque interaction ; sur un usage intensif, la note grimpe. Un modèle local ne coûte rien d’autre que l’électricité de votre machine : aucun abonnement, aucune facturation au token, quel que soit le volume de code généré.

Le deuxième est la confidentialité. Avec un assistant cloud, votre code part sur des serveurs distants — un problème réel pour du code client soumis à des engagements de confidentialité, ou simplement pour qui n’aime pas voir son travail quitter sa machine. En local, rien ne sort : vos fichiers restent chez vous, point. C’est l’argument décisif pour beaucoup de professionnels.

Le troisième est l’autonomie. Un modèle local, une fois téléchargé, fonctionne hors-ligne. Pas de coupure quand la connexion faiblit, pas de dépendance à la disponibilité d’un service distant. Vous travaillez dans le train, dans une zone mal couverte, ou pendant une panne de réseau, sans rien perdre. À cela s’ajoute un bénéfice d’apprentissage : comprendre comment fonctionne un agent et un modèle, plutôt que de consommer une boîte noire.

Les trois briques du montage

Le montage repose sur trois composants complémentaires, qu’il faut distinguer pour ne pas s’y perdre.

Le modèle local — via Ollama

Le modèle est le cerveau : c’est lui qui comprend votre demande et écrit le code. Ollama est l’outil qui télécharge ces modèles et les fait tourner sur votre machine, en exposant une API locale. On installe Ollama, on télécharge un modèle spécialisé dans le code, et le moteur est prêt. Tout commence là, dans le premier tutoriel.

L’agent — Cline

Un modèle seul sait écrire du code, mais pas agir dans votre projet. Cline est l’agent : une extension VS Code, open source sous licence Apache 2.0, qui orchestre le modèle pour créer des fichiers, exécuter des commandes et observer les résultats — toujours sous votre approbation. C’est lui qui transforme un modèle bavard en collaborateur qui fait avancer le projet. Son installation et sa connexion à Ollama sont détaillées dans le deuxième tutoriel.

L’éditeur — VS Code

Le tout vit dans VS Code, l’éditeur gratuit où Cline s’installe comme une extension. Vous y voyez les diffs proposés par l’agent, validez ou refusez, et gardez votre environnement de développement habituel. Rien de nouveau à apprendre côté éditeur : Cline s’intègre dans votre flux existant.

Agent ou autocomplétion : deux outils différents

Une confusion fréquente mérite d’être levée d’emblée. Il existe deux grandes familles d’assistants de code, et elles ne servent pas la même chose. L’autocomplétion — pensez à un outil comme Continue.dev — suggère la suite de votre ligne pendant que vous tapez : rapide, discrète, utile au fil de l’eau. L’agent — Cline — prend en charge une tâche entière : il lit le projet, écrit plusieurs fichiers, lance des commandes, corrige. L’un complète votre frappe ; l’autre exécute une mission.

Les deux sont complémentaires et peuvent tourner sur le même moteur Ollama. Beaucoup de développeurs gardent une autocomplétion locale pour le quotidien et sortent l’agent pour les tâches plus lourdes. Si l’autocomplétion vous intéresse, notre tutoriel sur Continue.dev dans VS Code en montre la mise en place ; ce parcours-ci se concentre sur l’agent, plus puissant et plus structurant.

Local ou cloud : le comparatif honnête

Soyons clairs pour éviter toute déception. Sur les tâches les plus difficiles — architecture d’un gros système, bugs subtils, raisonnement très poussé — les meilleurs modèles cloud gardent une avance réelle sur un modèle local de taille modeste. Le local ne prétend pas les égaler partout.

Mais sur le travail courant, l’écart se réduit fortement. Les modèles locaux récents couvrent aujourd’hui la grande majorité des tâches quotidiennes — complétion, refactoring, documentation, écriture de tests, débogage ordinaire — gratuitement et en privé. La comparaison se résume ainsi : le cloud offre plus de puissance brute au prix d’un coût par token et d’une exposition du code ; le local offre la gratuité, la confidentialité et l’autonomie, au prix d’un plafond de puissance plus bas. La meilleure stratégie est souvent hybride : faire l’essentiel en local, et basculer ponctuellement vers le cloud — dans le même Cline — pour les rares cas qui le justifient. Pour une vue d’ensemble des assistants cloud, voir notre guide de l’AI coding.

Le matériel : ce qu’il faut vraiment

La question revient toujours : « ma machine est-elle assez puissante ? ». La réponse est plus accessible qu’on ne le croit. Un modèle de code utile tourne dès 8 à 16 Go de RAM ; une carte graphique avec de la VRAM accélère fortement l’inférence mais n’est pas indispensable. Avec 8 Go, un modèle de 7 milliards de paramètres reste exploitable ; avec 24 Go de VRAM, un modèle 32B se rapproche nettement de la qualité du cloud sur le code courant.

Sans carte graphique dédiée, tout passe par le processeur : c’est plus lent, mais un modèle 7B reste utilisable pour la plupart des tâches. L’objectif n’est pas d’avoir la machine la plus puissante, mais de choisir un modèle adapté à la vôtre — un sujet que le tutoriel sur le choix du modèle traite en détail.

Les tutoriels du parcours

Chaque tutoriel construit une brique de l’atelier, autour du même projet « carnet ».

• Installer Ollama et un modèle de code en local — le moteur d’inférence.
• Installer Cline dans VS Code et le brancher sur Ollama — l’agent.
• Piloter l’agent Cline : modes Plan et Act — la méthode.
• Choisir le bon modèle local pour coder — le bon outil pour la tâche.
• Étendre Cline avec des serveurs MCP — donner des outils à l’agent.
• Sécuriser un agent de code local — le cadre défensif.

Comment l’écosystème se relie

Ce parcours ne vit pas isolé. Le moteur Ollama est le même que celui utilisé pour faire tourner DeepSeek-R1 en local ou pour les montages de RAG auto-hébergés. Les serveurs MCP que vous branchez sur Cline relèvent du même standard que nos tutoriels pour créer un serveur MCP. Et si vous utilisez par ailleurs un agent comme Claude Code, vous retrouverez les mêmes concepts — Plan, outils, approbations — appliqués au cloud. Comprendre la version locale éclaire toutes les autres.

Réalités du terrain

Le local prend tout son sens là où la connexion est incertaine et le budget compté. Une fois les modèles téléchargés — la seule étape gourmande en réseau, à faire quand le débit est bon — l’atelier fonctionne entièrement hors-ligne, sans consommer de données ni coûter un centime au token. Sur une machine modeste, un modèle 7B et des tâches courtes offrent déjà une expérience solide ; il suffit d’accepter une vitesse un peu plus posée. Et puisque rien ne quitte la machine, le montage convient au code confidentiel sans souci de conformité — un atout que peu d’assistants cloud peuvent offrir.

À qui s’adresse vraiment l’IA de code locale

Le montage Cline plus Ollama n’est pas un gadget de passionné : il répond à des besoins très concrets, et plusieurs profils y gagnent immédiatement.

Le développeur indépendant qui surveille ses coûts. Les abonnements et la facturation au token des assistants cloud s’accumulent, surtout quand on code beaucoup. Un modèle local supprime cette ligne de dépense : une fois le matériel là, l’usage est illimité et gratuit. Sur une année, l’économie est loin d’être symbolique.

Le professionnel tenu à la confidentialité. Consultants, prestataires sous accord de non-divulgation, équipes travaillant sur du code sensible : envoyer ce code à un service tiers est souvent tout simplement interdit. Le local résout le problème à la racine, puisque rien ne quitte la machine. C’est parfois la seule façon d’utiliser une IA de code dans un cadre contractuel strict.

L’étudiant et l’autodidacte. Apprendre à coder avec un assistant gratuit, sans carte bancaire ni quota, lève une barrière réelle. Et faire tourner soi-même un modèle, comprendre les notions de taille, de quantization, de contexte, forme une culture technique que la simple consommation d’un service cloud n’apporte pas.

Quiconque travaille avec une connexion incertaine. Là où le réseau est lent, cher ou intermittent, un outil hors-ligne change la donne : l’atelier fonctionne pareil, train ou panne de réseau, sans consommer de données. L’autonomie n’est pas un luxe, c’est parfois la condition même de pouvoir travailler.

Ce qu’un agent change dans la pratique

Adopter un agent de code ne se résume pas à « taper moins » : cela déplace la nature même du travail. Avec un agent comme Cline, vous passez moins de temps à écrire mécaniquement du code, et davantage à décrire ce que vous voulez, à relire ce qui est produit, et à décider de ce qui entre dans le projet. Votre rôle glisse de l’exécution vers la conception et la supervision.

Ce glissement a une conséquence importante : la compétence clé devient la capacité à formuler clairement un besoin et à juger un résultat. Un agent amplifie un bon développeur, il ne remplace pas le jugement. C’est pourquoi tout ce parcours insiste sur la relecture des diffs, la méthode Plan avant Act, et la revue avant de committer : la valeur que vous apportez n’est plus dans la frappe, mais dans le discernement. Bien employé, l’agent vous libère des tâches répétitives — écrire un test de plus, refactorer une fonction, documenter un module — pour vous concentrer sur ce qui demande réellement de l’intelligence humaine : l’architecture, les choix de conception, la compréhension du besoin métier.

Concrètement, sur le projet « carnet », vous verrez l’agent abattre en minutes le travail d’écriture fastidieux, pendant que vous gardez la main sur les décisions structurantes. C’est cette répartition — la machine pour le volume, l’humain pour le sens — qui rend l’outil réellement productif plutôt que gadget.

Limites et précautions à garder en tête

Aucun outil n’est parfait, et présenter le local sans ses limites serait malhonnête. La première limite est la puissance : sur un problème vraiment ardu, un modèle local de taille modeste produira parfois une solution maladroite là où un grand modèle cloud trouverait juste. D’où l’intérêt de la stratégie hybride, qui garde une porte de secours vers le cloud pour les rares cas extrêmes.

La deuxième limite est la vitesse sur petit matériel : sans carte graphique, les réponses sont plus lentes, et il faut accepter un rythme plus posé. Ce n’est pas rédhibitoire pour apprendre ou pour des tâches ordinaires, mais cela compte si vous attendez l’instantanéité.

La troisième tient à la responsabilité : un agent qui agit sur vos fichiers et exécute des commandes peut faire des dégâts si on lui laisse trop de latitude. C’est le sujet entier du tutoriel sur la sécurité — approbations strictes, secrets isolés, périmètre limité, revue systématique. Ces précautions ne sont pas optionnelles : elles sont le prix de l’autonomie qu’on accorde à l’outil. En les gardant à l’esprit, vous profitez de toute la puissance du local sans en subir les revers.

Un domaine qui évolue vite

L’IA de code locale progresse à un rythme soutenu. Les modèles gagnent en qualité à taille égale, les outils comme Cline et Ollama s’enrichissent de version en version, et ce qui demandait hier une machine coûteuse tourne aujourd’hui sur un ordinateur portable correct. Cette vitalité a une conséquence pratique : certains détails — nom du modèle vedette du moment, emplacement exact d’un réglage — changeront. Les principes, eux, restent stables, et c’est ce que ce parcours vous apprend : installer un moteur, brancher un agent, le piloter, choisir un modèle, l’outiller, le sécuriser. Maîtrisez cette colonne vertébrale, et vous resterez à l’aise quelle que soit l’évolution des outils. En cas de doute sur un point précis, la documentation officielle de chaque projet reste la référence à jour.

L’économie concrète du local

Chiffrons l’argument du coût, car il est souvent décisif. Un développeur qui s’appuie quotidiennement sur un assistant cloud paie selon son volume d’usage — abonnement mensuel et, au-delà, facturation à l’utilisation. Sur une année d’usage intensif, l’addition représente une somme non négligeable, qui se répète chaque année. Le montage local, lui, ne demande qu’un investissement matériel ponctuel — souvent une machine que vous possédez déjà — puis plus rien : usage illimité, gratuit, indéfiniment.

Le calcul penche d’autant plus vers le local que l’usage est intensif et durable. Pour un usage occasionnel, le cloud reste pratique et bon marché ; pour qui code tous les jours, le local devient vite imbattable, d’autant qu’il ajoute la confidentialité et l’autonomie par-dessus l’économie. La logique est la même que pour l’auto-hébergement en général : on échange une facture récurrente contre la maîtrise de ses outils.

Pourquoi Cline pour l’agent

Il existe plusieurs agents de code ; ce parcours retient Cline pour des raisons précises. D’abord, il est open source sous licence Apache 2.0 : pas de boîte noire, pas de dépendance à un éditeur unique. Ensuite, il gère nativement les modèles locaux via Ollama, avec une auto-détection qui simplifie la configuration. Sa séparation Plan et Act en fait un outil pédagogique idéal pour apprendre à piloter un agent avec méthode. Enfin, son support de MCP permet d’étendre ses capacités proprement, et son système de diffs et de checkpoints garde l’humain au centre des décisions. Cet ensemble — ouvert, local-first, méthodique et extensible — en fait une porte d’entrée idéale vers le codage assisté souverain, sans pour autant vous enfermer : les concepts appris ici se transposent à d’autres agents.

Erreurs fréquentes

Questions fréquentes

Est-ce vraiment gratuit ?
Oui. Ollama et Cline sont open source et gratuits, et les modèles de la bibliothèque se téléchargent sans frais. Vous ne payez que votre matériel et son électricité — aucun abonnement, aucune facturation au token.

Quel matériel faut-il ?
Un modèle utile tourne dès 8 à 16 Go de RAM. Une carte graphique accélère beaucoup mais n’est pas obligatoire ; un modèle 7B reste exploitable sur processeur.

Est-ce aussi bon que Cursor ou Copilot ?
Pas sur les tâches les plus difficiles, où le cloud garde l’avantage. Mais pour la grande majorité du travail quotidien, un bon modèle local fait l’affaire, gratuitement et en privé.

Mon code part-il sur Internet ?
Non, avec un modèle local. Tout se passe sur votre machine. C’est l’argument central : confidentialité totale, idéale pour du code client.

Cline est-il open source ?
Oui, sous licence Apache 2.0. C’est un agent de code qui s’installe dans VS Code et fonctionne avec de nombreux fournisseurs, dont Ollama en local.

Quel modèle choisir pour commencer ?
Un modèle spécialisé code de 7 milliards de paramètres est le bon point de départ. Descendez à 3B sur une machine modeste, montez à 32B avec 24 Go de VRAM.

Faut-il savoir programmer ?
Des bases aident à relire et valider le travail de l’agent — ce qui reste indispensable. Mais le parcours est conçu pour être suivi pas à pas, y compris par un développeur débutant.

Par où commencer

Si vous débutez, ouvrez le premier tutoriel et installez Ollama avec un modèle 7B : en vingt minutes, vous aurez une IA qui code sur votre machine, gratuitement. Puis remontez la série dans l’ordre. En quelques sessions, vous passerez de la curiosité à un atelier complet — un agent local, outillé et sécurisé, capable de vous épauler sur de vrais projets sans jamais exposer votre code ni vous coûter un centime.

• Point de départ : Installer Ollama et un modèle de code en local.
• Documentation officielle : github.com/cline/cline, docs.cline.bot et ollama.com.