Faire tourner une IA locale : le guide simple avec Ollama et Codex

Et si ton prochain assistant IA tournait directement sur ton ordinateur ?

Quand tu utilises un assistant en ligne, tu écris une demande, des serveurs travaillent quelque part et une réponse revient. Entre les deux se trouvent des modèles, une connexion Internet, des quotas et parfois une facture.

Installer une IA locale permet de faire fonctionner un modèle directement sur ton ordinateur, pour discuter, résumer des textes ou préparer des contenus. Avec un environnement adapté, tu peux aussi lui donner accès à un dossier pour analyser des fichiers et créer des documents.

Pas besoin de construire un datacenter dans le garage. Pour commencer, un outil comme Ollama et un modèle adapté à ta machine suffisent.

Nous allons avancer progressivement :

1. Comprendre ce qui fonctionne réellement en local.
2. Installer Ollama et télécharger un premier modèle.
3. Vérifier ses performances.
4. Le connecter à un environnement agentique comme Codex.
5. Tester une organisation documentaire, notamment avec Obsidian.
6. Comprendre quand conserver une porte vers le cloud.

Bienvenue dans le petit laboratoire local.

Une IA locale, concrètement, qu’est-ce que c’est ?

Un assistant IA peut réunir plusieurs éléments que l’on confond facilement : une interface, un modèle et des outils.

Pour comprendre notre installation, séparons les rôles.

Élément	Son rôle
Le modèle IA	Produit les réponses à partir des informations reçues
Ollama	Télécharge, charge et exécute les modèles compatibles
L’interface de conversation	Permet d’échanger avec le modèle
L’environnement agentique	Donne au modèle des outils pour lire des fichiers ou effectuer des actions

Ollama : le moteur qui fait fonctionner les modèles

Ollama permet de télécharger et d’exécuter des modèles sur Windows, macOS et Linux.

Il peut aussi fournir une API locale : une porte d’entrée permettant à un autre logiciel de lui envoyer une demande.

Cette API dispose notamment d’une compatibilité avec une partie de l’API OpenAI. Cela facilite certaines intégrations, mais ne signifie pas que toutes les fonctionnalités de tous les logiciels deviennent automatiquement compatibles.

Le modèle : le cerveau choisi pour la tâche

Qwen, Gemma et GPT-OSS sont des familles de modèles différentes.

Leur taille, leur comportement, leurs capacités et leurs licences varient. Certains sont adaptés à la conversation, d’autres à la programmation, aux images ou à l’utilisation d’outils.

« Modèle disponible au téléchargement » ne signifie pas nécessairement « logiciel entièrement open source ». Vérifie sa licence si tu envisages une redistribution ou un usage commercial particulier.

Codex : un atelier pour travailler sur des fichiers

Un environnement agentique comme Codex peut proposer au modèle des outils pour explorer un dossier, lire des documents, écrire des fichiers ou lancer certaines commandes.

Le modèle choisit une action. L’environnement l’exécute selon ses permissions, puis lui retourne le résultat.

C’est ce mécanisme qui permet de passer d’une conversation à un travail dans un projet.

Le modèle ne découvre pas tout seul ton disque dur. Il travaille avec ce que l’application lui transmet et les accès qu’elle lui accorde.

Pourquoi installer une IA sur son ordinateur ?

Garder certains traitements sur sa machine

Un modèle exécuté localement peut traiter des notes, des brouillons ou du code sans envoyer ces demandes à un service d’inférence distant.

Ollama précise que les prompts et les données des exécutions locales ne lui sont pas transmis.

Cela peut être intéressant pour :

• résumer des notes personnelles ;
• reformuler des brouillons ;
• extraire des informations ;
• préparer des fiches documentaires ;
• comparer des fichiers ;
• travailler sur une copie de sa base Obsidian.

Mais un modèle local ne rend pas automatiquement toute l’installation privée.

Si ton assistant utilise une recherche Web, un connecteur, un dossier synchronisé ou une API externe, des données peuvent sortir de la machine. Il faut regarder l’ensemble du parcours, pas seulement l’emplacement du modèle.

Éviter la facturation au token pour les générations locales

Avec un modèle téléchargé et exécuté chez toi, tu ne paies pas chaque génération à un fournisseur d’API.

Il reste des coûts : matériel, électricité, stockage et temps de calcul.

Pour des tâches répétitives, cela peut devenir intéressant. Par exemple, produire une première synthèse de nombreux documents ou appliquer une même structure à une série de notes.

Le local déplace le coût vers ta machine. Il ne le fait pas disparaître par magie.

Choisir davantage ses outils

Séparer le modèle de l’interface permet de tester plusieurs configurations.

Tu peux garder le même environnement de travail et changer de modèle, ou conserver Ollama et essayer une autre interface compatible.

C’est agréable d’avoir quelques outils dans son propre garage. Encore faut-il choisir la bonne clé pour le bon boulon.

Une IA locale est-elle aussi performante que ChatGPT ou Claude ?

Cela dépend du modèle, de la machine et de la tâche.

Un petit modèle peut produire une reformulation correcte, puis échouer sur une consigne complexe. Un modèle plus puissant peut mieux raisonner, mais demander davantage de mémoire et répondre beaucoup plus lentement.

Il faut aussi distinguer deux tests :

• Sait-il discuter correctement ?
• Sait-il utiliser les outils d’un agent de façon fiable ?

Réussir le premier ne garantit pas le second.

Pour débuter, vise un résultat observable : résumer trois notes correctement, extraire quelques informations ou créer un document simple.

Tu pourras ensuite comparer avec un modèle distant. L’objectif est de savoir quel outil te rend service, pour quel travail.

Quel ordinateur faut-il pour faire tourner une IA locale ?

Trois ressources comptent particulièrement.

La mémoire vive : la place disponible pour travailler

La RAM sert aux logiciels et aux données utilisés par l’ordinateur.

Un modèle peut en consommer une quantité importante, en plus de ton système, de ton navigateur et des autres applications ouvertes.

Sur certaines machines, notamment les Mac à mémoire unifiée, la répartition ne fonctionne pas comme sur un PC équipé d’une carte graphique dédiée.

La mémoire graphique : un facteur important pour la vitesse

La VRAM est la mémoire d’une carte graphique dédiée.

Lorsqu’un modèle peut être exécuté efficacement sur un GPU compatible, les réponses peuvent être bien plus rapides. Le support dépend du matériel, des pilotes et du système : consulte la documentation de compatibilité matérielle d’Ollama.

Une exécution sur processeur reste possible dans certaines configurations, avec une vitesse parfois beaucoup moins confortable.

Le stockage : les modèles prennent de la place

Les fichiers téléchargés peuvent peser plusieurs gigaoctets, voire beaucoup plus.

Le poids du téléchargement n’est pas la mémoire nécessaire à l’exécution. Il faut aussi tenir compte du contexte, des calculs intermédiaires et de l’application utilisée.

Pour une première découverte, commence par un modèle compact. Ne télécharge pas le plus gros animal de la bibliothèque avant de savoir si tu as la place pour sa cage.

Étape 1 : installer Ollama

Rends-toi sur la page officielle de téléchargement d’Ollama, puis sélectionne ton système.

Sur Windows

Télécharge l’installateur et suis les étapes.

Ollama fonctionne comme une application native, tourne en arrière-plan et rend la commande ollama disponible dans PowerShell ou le terminal. L’installation standard ne demande normalement pas de droits administrateur. Consulte les prérequis Windows pour vérifier la compatibilité de ton système.

Après l’installation, ouvre un nouveau terminal et tape :

ollama --version

Une version doit s’afficher.

Si la commande n’est pas reconnue, ferme puis rouvre le terminal. Vérifie ensuite qu’Ollama est bien installé et lancé.

Sur macOS

Télécharge l’application et suis les instructions d’installation. Lance ensuite Ollama, puis ouvre Terminal pour effectuer la même vérification :

ollama --version

Sur Linux

Utilise les instructions proposées sur la page officielle pour ta distribution.

Pour ce tutoriel, nous gardons une installation locale simple. Docker n’est pas nécessaire pour découvrir le fonctionnement.

Étape 2 : choisir son premier modèle local

Les noms peuvent vite ressembler à une collection de références de pièces automobiles : 4B, 9B, Q4, MoE…

Voici les deux notions à retenir.

B désigne des milliards de paramètres. Ce nombre donne une indication sur la taille du modèle, sans suffire à prédire ses performances.

La quantification réduit la précision utilisée pour représenter certains paramètres. Elle permet souvent de réduire les besoins en mémoire, avec des compromis qui dépendent du modèle et de la méthode.

Qwen 3.5 : une base pour tester conversation et outils

La famille Qwen 3.5 sur Ollama propose notamment des variantes 4B et 9B, avec prise en charge des images et des outils selon les modèles distribués.

Au moment de la vérification, les fichiers proposés se situent autour de 3,3 à 4 Go pour la variante 4B, et 6,6 à 7,6 Go pour la 9B, selon la variante choisie. Ces tailles peuvent évoluer.

Pour commencer :

ollama run qwen3.5:4b

Si ta machine dispose de davantage de ressources, tu pourras comparer avec :

ollama run qwen3.5:9b

Le premier lancement télécharge le modèle, puis ouvre une conversation.

Pour la suite agentique, nous utiliserons Qwen comme point de départ, en vérifiant que la variante apparaît parmi les modèles compatibles de l’intégration.

Gemma 3 4B : une alternative pour découvrir le chat local

Gemma 3, la famille de Google, constitue une autre possibilité pour tester la conversation, le résumé et l’analyse d’images.

ollama run gemma3:4b

Le fichier de cette variante est actuellement d’environ 3,4 Go dans le catalogue Ollama.

Utilise ce test pour évaluer la qualité et la vitesse des réponses. Ne suppose pas pour autant que toutes les fonctions agentiques seront prises en charge.

GPT-OSS 20B : à explorer avec davantage de ressources

La famille GPT-OSS distribuée sur Ollama propose notamment un modèle 20B orienté raisonnement et outils.

ollama run gpt-oss:20b

Son téléchargement représente actuellement environ 14 Go. Prévois une marge de ressources pour son exécution, particulièrement avec un contexte important.

Ne le choisis pas uniquement parce que le nombre est plus gros. Un modèle qui met un temps déraisonnable à terminer chaque tâche ne sera pas forcément ton meilleur assistant.

Étape 3 : vérifier que ton IA locale fonctionne

Une fois la conversation ouverte, commence par une demande simple :

Explique-moi en français ce qu’est une API avec la métaphore d’un restaurant.

Termine par une définition technique en deux phrases.

Puis teste un résumé :

Résume le texte ci-dessous en cinq idées principales.

Conserve les noms et les chiffres présents.
N’ajoute aucune information extérieure.
Si une information est ambiguë, indique-le.

Texte :
[COLLE ICI UN COURT TEXTE NON SENSIBLE]

Vérifie trois choses :

1. Le modèle répond-il dans la langue demandée ?
2. Le résumé respecte-t-il le texte ?
3. La vitesse est-elle acceptable pour ton usage ?

Une réponse qui s’affiche prouve que le modèle fonctionne. Une réponse fidèle et utile commence à prouver qu’il peut t’aider.

Les commandes utiles pour observer l’installation

Dans une autre fenêtre de terminal :

ollama list

Cette commande affiche les modèles installés.

Pour voir les modèles actuellement chargés :

ollama ps

Les informations affichées permettent notamment de vérifier la répartition CPU/GPU et le contexte alloué.

Dans une conversation de terminal Ollama, tu peux utiliser /bye pour quitter le chat.

Étape 4 : connecter Ollama à Codex

Nous avons maintenant un modèle capable de répondre.

Pour travailler directement avec des fichiers, il faut ajouter un environnement qui lui donne des outils.

Deux parcours sont possibles : l’application de bureau et la CLI, c’est-à-dire la version en ligne de commande.

Le parcours graphique documenté par Ollama

La documentation actuelle présente l’intégration dans ChatGPT Desktop, en mode Codex. L’ancienne adresse consacrée à Codex App redirige vers ce nouveau parcours.

Elle demande Ollama 0.34.0 ou une version ultérieure :

1. Ouvre l’application Ollama.
2. Cherche la rubrique Apps.
3. Active ChatGPT (Desktop).
4. Suis les instructions de configuration et de redémarrage.
5. Dans les paramètres Ollama, sélectionne les modèles compatibles à rendre disponibles.
6. Ouvre l’application ChatGPT et utilise le mode Codex.
7. Choisis explicitement ton modèle Ollama local.

Le guide d’intégration Ollama et ChatGPT Desktop détaille ce fonctionnement. Seules les requêtes adressées à un modèle Ollama passent par cette connexion ; le chat ordinaire et les modèles natifs conservent leur fonctionnement habituel.

Si tu ne retrouves pas ces options, vérifie les versions et la disponibilité sur ta plateforme. Le guide de démarrage Ollama décrit actuellement le parcours graphique sur macOS. Évite de chercher indéfiniment un bouton absent de ton installation.

Dans ce cas, utilise la voie CLI ci-dessous.

L’alternative : Codex CLI avec Ollama

La documentation officielle OpenAI de Codex CLI présente l’environnement en terminal.

La procédure d’intégration Ollama indique notamment cette installation via npm, qui suppose d’avoir Node.js et npm disponibles :

npm install -g @openai/codex

Depuis ton dossier de travail, tu peux ensuite lancer :

ollama launch codex

Ollama prépare un profil dédié et propose les modèles compatibles.

Le guide Ollama pour Codex CLI documente aussi une connexion explicite avec le mode local :

codex --oss --local-provider ollama -m qwen3.5:4b

Les options --oss et --local-provider sont décrites dans la référence officielle des commandes Codex.

Garde les contrôles de permissions de l’application. Pour un premier test, nous allons travailler sur quelques fichiers sans valeur critique.

Comprendre le contexte avant de confier un dossier à l’agent

La fenêtre de contexte représente la quantité d’informations que le modèle peut traiter dans une même demande : consignes, conversation, contenu des fichiers et résultats d’outils.

Imagine sa table de travail. Elle possède une surface limitée.

Un modèle annoncé avec un grand contexte maximal ne fonctionne pas forcément avec cette capacité dans ta configuration.

Ollama recommande au moins 64 000 tokens pour les usages comme les agents et les outils de programmation. Augmenter le contexte consomme davantage de mémoire.

Dans l’application Ollama, le réglage se trouve dans les paramètres. Utilise ollama ps pour vérifier ce qui est effectivement alloué.

Si ta machine ne tient pas ce réglage, réduis la taille des tâches ou reste d’abord sur des conversations courtes. Ne lui donne pas deux cents fichiers en espérant que la bonne volonté remplace la RAM.

Étape 5 : analyser un premier dossier sans le modifier

Crée un dossier nommé TEST-IA-LOCALE dans ton explorateur de fichiers.

Ajoute trois fichiers texte ou Markdown :

• notes.md : quelques informations sur un projet ;
• idees.md : des idées et des pistes ;
• projet.md : les objectifs et les prochaines étapes.

Sur Windows, vérifie que les extensions sont visibles : notes.md.txt reste un fichier texte portant un autre nom.

Ouvre ce dossier comme espace de travail dans ton environnement Codex. Avec la CLI, place-toi dans ce dossier avant de lancer l’agent.

Envoie ce prompt :

Analyse les fichiers texte et Markdown du dossier actuel.

Ne modifie aucun fichier.
N’utilise pas de recherche Web ni de service externe.

Présente :
1. La liste des fichiers effectivement lus.
2. Le sujet principal de chaque fichier.
3. Les informations répétées.
4. Les contradictions éventuelles.
5. Une proposition d’organisation.

Si tu ne peux pas lire un fichier, indique-le.
Ne déplace, renomme ou supprime rien.
Attends mon accord avant toute modification.

Comment savoir si le test est réussi ?

L’agent doit citer les bons noms de fichiers et décrire leur contenu réel.

Vérifie aussi qu’aucun fichier n’a changé.

S’il répond seulement avec des conseils génériques sans lire les documents, le modèle ne réalise peut-être pas correctement les appels d’outils. La discussion fonctionne, mais la partie agentique reste à régler.

Teste alors un seul fichier, vérifie les permissions et essaie un modèle compatible plus adapté.

Étape 6 : créer une synthèse avec ton modèle local

Une fois l’analyse vérifiée, demande une création limitée :

À partir des fichiers que tu as effectivement lus,
crée un nouveau fichier nommé SYNTHESE.md.

S’il existe déjà, ne l’écrase pas : demande-moi quoi faire.

Structure attendue :

# Synthèse

## Objectif du projet
## Informations importantes
## Idées principales
## Questions encore ouvertes
## Prochaines étapes

Pour les informations importantes, indique le fichier source.

N’invente aucune information manquante.
Signale les contradictions au lieu de les résoudre arbitrairement.

Ne modifie, déplace ou supprime aucun fichier existant.
N’utilise aucun service externe.

Le résultat attendu est concret : un nouveau fichier dans ton dossier, avec une synthèse que tu peux comparer aux originaux.

L’agent est utile lorsqu’il produit un résultat vérifiable. La longueur de sa réponse n’est pas un contrôle qualité.

Utiliser une IA locale avec Obsidian

Une base Obsidian, appelée vault, repose principalement sur des fichiers Markdown, auxquels peuvent s’ajouter des pièces jointes et des fichiers de configuration.

Cela en fait un terrain intéressant pour l’assistance documentaire.

Commence sur une copie d’un petit ensemble de notes, sans connecter immédiatement toute ta base.

Crée trois dossiers :

• SOURCES, pour les documents d’origine ;
• NOTES, pour tes notes de travail ;
• SYNTHESES, pour les documents générés.

Prompt : créer des fiches documentaires

Tu travailles sur une copie de ma base documentaire.

Analyse uniquement les fichiers Markdown du dossier SOURCES.

Pour chaque fichier :
- identifie le sujet principal ;
- relève les noms, dates et chiffres importants ;
- distingue les faits, les opinions et les questions ;
- conserve les liens présents ;
- indique les informations manquantes ;
- crée une synthèse Markdown dans SYNTHESES.

Ajoute un lien vers le fichier source dans chaque synthèse.

Ne modifie jamais SOURCES.
Ne touche pas au dossier .obsidian.
N’écrase aucun fichier existant.
Ne consulte aucun service externe.

Commence par un seul document.
Attends mon retour avant de traiter les suivants.

Prompt : structurer les nouvelles notes Obsidian

Pour les nouvelles notes créées dans SYNTHESES :

- utilise un titre H1 ;
- crée des sections utiles au contenu ;
- conserve les sources et les dates ;
- propose au maximum cinq tags pertinents ;
- utilise des liens [[Nom de la note]] uniquement si la note cible existe ;
- distingue les informations de la source de tes suggestions ;
- indique les incertitudes.

Ne crée pas de liens vers des notes imaginaires.
Ne modifie aucun document existant sans mon accord.

Ce fonctionnement aide à organiser des notes. Il ne crée pas automatiquement une mémoire parfaite ni un système capable de retrouver toute information dans des milliers de fichiers.

Pour cela, on peut ensuite explorer un RAG : un mécanisme qui recherche des passages pertinents avant de les transmettre au modèle.

Traiter de nombreux fichiers : l’intérêt du batch

Un traitement batch consiste à répéter une opération sur plusieurs éléments.

Par exemple :

• produire une fiche par document ;
• extraire des dates ;
• proposer des catégories ;
• uniformiser une structure Markdown ;
• générer un index ;
• repérer des doublons possibles.

Le modèle local évite une facturation d’inférence au token, mais il consomme toujours du temps machine.

Commence par trois fichiers, puis dix

Avant de traiter cinq cents notes, vérifie la qualité sur un petit échantillon.

Pour chaque résultat, contrôle les informations conservées, les omissions et les ajouts.

Prévois également une trace des fichiers traités. Une automatisation doit pouvoir reprendre après une interruption sans écraser le travail précédent.

Pour détecter de vrais fichiers identiques, un outil de comparaison classique sera souvent plus fiable qu’un modèle de langage. L’IA devient intéressante pour repérer des contenus proches dont la formulation diffère.

Local, confidentialité et permissions : où sont les limites ?

Trois contrôles différents sont nécessaires.

1. Quel modèle est réellement utilisé ?

Un modèle exécuté via Ollama peut être local ou hébergé dans le cloud.

Choisis explicitement une variante téléchargée sur ta machine. Une variante portant la mention cloud ne correspond pas à une exécution locale.

2. Quels outils peuvent envoyer des données ?

Recherche Web, connecteurs, passerelles de messagerie et API distantes possèdent leur propre parcours de données.

Pour un exercice documentaire local, désactive les outils externes inutiles.

Ollama propose aussi un mode local uniquement, décrit dans sa FAQ sur la désactivation des fonctions cloud. Ce réglage concerne Ollama ; il ne coupe pas les autres connexions d’un logiciel tiers.

3. Quels fichiers l’agent peut-il modifier ?

Un prompt comme « ne supprime rien » est une instruction, pas une barrière technique.

Les permissions de l’application, une copie de travail et une sauvegarde apportent des protections complémentaires.

Pour commencer, accorde l’accès au dossier de test. Le grand ménage de toutes tes archives peut attendre que le bibliothécaire ait montré qu’il savait ranger trois livres.

Ajouter le cloud : une option, pas une bascule automatique

Une installation hybride permet de conserver certains traitements sur sa machine et d’utiliser un service distant pour d’autres besoins.

Tu peux, par exemple :

• reformater des notes localement ;
• comparer un résultat avec un autre modèle ;
• utiliser un modèle distant pour une tâche dépassant les capacités de ta configuration.

Le passage au cloud doit rester explicite. Il ne faut pas qu’un échec local déclenche discrètement l’envoi d’un dossier confidentiel.

OpenRouter et les modèles gratuits

OpenRouter donne accès à différents modèles via une API.

Son routeur openrouter/free sélectionne parmi les modèles gratuits disponibles, en tenant compte des fonctions requises. Ce n’est pas nécessairement le même modèle d’une requête à l’autre.

Au moment de la vérification, OpenRouter indique pour les modèles gratuits une limite de 20 requêtes par minute et 50 par jour, portée à 1 000 requêtes quotidiennes après l’achat d’au moins 10 dollars de crédits. Ces conditions peuvent évoluer : consulte les limites officielles.

Un agent peut consommer plusieurs requêtes pour une seule tâche.

Cette option peut servir à expérimenter. Elle implique néanmoins un compte, une clé API, une configuration compatible et un traitement distant des données.

L’installation Ollama de ce tutoriel ne connecte pas automatiquement OpenRouter à Codex. Ce serait une configuration supplémentaire, à vérifier séparément.

Pourquoi un prompt ne suffit pas à créer un routage intelligent

Écrire « utilise le local, puis le cloud si nécessaire » ne donne pas au modèle le pouvoir de changer lui-même de fournisseur.

Il faut un logiciel ou une orchestration qui possède réellement ces fonctions.

Tu peux commencer par une politique manuelle :

Politique de travail :

Utilise uniquement le modèle local pour les documents de ce dossier.

Si tu ne peux pas accomplir une tâche :
- explique le blocage ;
- indique ce qui manque ;
- propose une solution ;
- attends ma décision.

Ne transmets aucun contenu à une API distante.
Ne change pas de fournisseur automatiquement.

Les fichiers marqués PRIVATE ne doivent jamais être inclus
dans une demande externe.

Cette politique clarifie le comportement attendu. Les restrictions importantes doivent aussi être appliquées dans les outils et les permissions.

Et Hermes Agent ?

Hermes Agent, développé par Nous Research, constitue une autre piste.

Ollama documente aujourd’hui une intégration directe :

ollama launch hermes

Le guide Hermes avec Ollama décrit la sélection du modèle et la configuration. Une interface Hermes Desktop dispose également de son propre parcours.

Hermes peut être intéressant pour explorer mémoire, skills et enchaînements d’outils.

Je le garderais comme deuxième expérience : commence par vérifier qu’un modèle local réalise correctement une tâche documentaire simple, puis compare les environnements avec le même exercice.

La compatibilité dépend de la combinaison entre le modèle, l’agent et leurs versions. Ajouter un nouvel outil ne corrige pas automatiquement les limites du modèle.

Les problèmes fréquents et les vérifications utiles

Problème	Première vérification
La commande ollama n’est pas reconnue	Rouvrir le terminal après installation
Le téléchargement échoue	Vérifier connexion, espace disque et nom exact du modèle
Le modèle répond très lentement	Consulter ollama ps, réduire le modèle ou le contexte
Ollama indique un manque de mémoire	Fermer d’autres applications et choisir une variante plus petite
Le modèle discute mais ne lit pas les fichiers	Vérifier outils, permissions et compatibilité du modèle
Les réponses oublient une partie des documents	Réduire le nombre de fichiers et vérifier le contexte alloué
Le bouton d’intégration graphique est absent	Vérifier version, plateforme et documentation actuelle
La synthèse contient des inventions	Exiger les fichiers sources et contrôler un petit échantillon

Quand un test échoue, reviens à l’étape précédente.

Si la conversation Ollama fonctionne mais que l’agent échoue, inutile de retélécharger tous les modèles au hasard. Le problème peut se situer dans l’intégration ou l’utilisation des outils.

Prompt supplémentaire : auditer un projet sans le modifier

Une fois le fonctionnement maîtrisé, tu peux utiliser cette base :

Analyse le projet du dossier actuel sans modifier ses fichiers.

Commence par identifier sa structure.
Lis les fichiers nécessaires par petits ensembles.

Présente :
- l’objectif apparent du projet ;
- les dossiers et fichiers importants ;
- les dépendances identifiées ;
- les informations manquantes ;
- les éléments potentiellement obsolètes, avec justification ;
- les améliorations possibles.

Distingue ce que tu as vérifié de ce que tu supposes.
Indique les fichiers consultés.
N’exécute aucune commande qui modifie le projet.
N’utilise aucun service externe.

Termine avec trois sections :
## Priorité haute
## Priorité moyenne
## Priorité basse

Attends ma validation avant toute action.

« Potentiellement obsolète » ne signifie pas « bon à supprimer ». Un fichier peu utilisé peut encore remplir une fonction importante.

Questions fréquentes sur l’IA locale avec Ollama

Peut-on utiliser Ollama sans Internet ?

Un modèle déjà téléchargé peut effectuer des générations locales sans connexion. Le téléchargement initial, les mises à jour et les services distants nécessitent une connexion.

L’interface ou les outils associés peuvent avoir leurs propres besoins réseau.

Faut-il une carte graphique puissante ?

Cela dépend du modèle et du confort recherché. Certains modèles compacts peuvent fonctionner sans GPU dédié, mais plus lentement.

Vérifie la compatibilité avant d’acheter du matériel. Un premier essai sur ta machine actuelle t’en apprendra déjà beaucoup.

Une IA locale est-elle gratuite ?

Les générations exécutées sur ta machine ne sont pas facturées au token par une API distante.

Le matériel, l’électricité et les éventuels services complémentaires ont toujours un coût.

Peut-elle lire des PDF, des images ou des documents Word ?

Cela dépend du modèle et des outils de l’application.

Un fichier Markdown se lit facilement comme du texte. Un PDF scanné peut demander une reconnaissance de caractères. Un document Word peut nécessiter une extraction. La capacité du modèle à comprendre des images ne garantit pas que l’intégration lui transmette tous les formats correctement.

Installer Ollama revient-il à installer ChatGPT localement ?

Non. Tu installes un moteur capable d’exécuter certains modèles compatibles.

Même lorsqu’un modèle Ollama apparaît dans une interface ChatGPT ou Codex, cela ne transforme pas les modèles propriétaires du service en modèles téléchargés sur ton ordinateur.

Ton premier laboratoire : un modèle, trois fichiers, une synthèse

Pour découvrir l’IA locale, commence avec un objectif assez petit pour pouvoir vérifier le résultat.

Installe Ollama. Lance un modèle compact. Teste sa compréhension sur un texte court. Puis connecte un environnement compatible et demande-lui de lire trois fichiers avant de créer une synthèse.

Tu sauras alors si ton ordinateur offre une vitesse acceptable, si le modèle respecte les sources et si les outils fonctionnent.

Ensuite, tu pourras ajouter Obsidian, des traitements par lots, une recherche documentaire ou une connexion cloud distincte.

Ne construis pas le niveau sept lorsque tu n’as pas encore testé le niveau un. C’est la meilleure manière de passer trois heures à configurer une magnifique usine qui ne fabrique encore rien.

L’intérêt du local apparaît dans ces premiers usages : un dossier mieux compris, une note structurée, un traitement que tu peux répéter et contrôler.

Le laboratoire commence là.