Discuter d’un projet

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

Cyphia présente un workflow pour faire tourner une IA en local avec Ollama, Codex et un modèle comme Qwen ou Gemma.

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

Quand on utilise ChatGPT, Claude ou Gemini, le fonctionnement paraît presque magique.

Tu écris une demande.

Elle part quelque part sur Internet.

Des serveurs travaillent.

Une réponse revient.

Entre les deux se trouvent pourtant des modèles, des serveurs, des API, des quotas et parfois une facture.

Il existe une autre possibilité :

faire tourner directement un modèle d’intelligence artificielle sur son propre ordinateur.

Pas besoin de construire un datacenter dans le garage.

Pas besoin non plus de comprendre CUDA, Python, Transformers et quarante lignes de terminal avant de poser sa première question.

Aujourd’hui, un outil comme Ollama permet de télécharger et lancer facilement des modèles ouverts sur Windows, macOS et Linux.

Et là où cela devient vraiment intéressant, c’est qu’on n’est plus obligé de les utiliser dans une petite fenêtre de terminal austère.

On peut connecter cette IA locale à une interface agentique comme Codex.

On obtient alors quelque chose qui ressemble davantage aux nouveaux assistants IA capables de :

Avec une différence fondamentale :

le cerveau utilisé peut tourner sur ta propre machine.

Bienvenue dans le petit laboratoire local. 🧪

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

Commençons par enlever un peu de brouillard.

Un assistant IA moderne peut être simplifié en deux morceaux.

INTERFACE
        ↓
MODÈLE IA

Par exemple :

ChatGPT
   ↓
modèles OpenAI

Dans notre installation, nous allons séparer ces deux éléments.

CODEX
   ↓
OLLAMA
   ↓
QWEN / GEMMA / GPT-OSS
   ↓
TON ORDINATEUR

Ollama

Ollama s’occupe principalement de :

Ollama expose notamment une API et une interface compatible avec une partie du format API OpenAI.

Le modèle

C’est réellement le « cerveau ».

Par exemple :

Codex

Codex joue ici le rôle de l’environnement de travail.

Au lieu d’avoir uniquement :

Question → Réponse

on se rapproche de :

OBJECTIF
   ↓
analyse du dossier
   ↓
lecture des fichiers
   ↓
réflexion
   ↓
actions
   ↓
résultat

C’est cette différence qui rend l’expérience particulièrement intéressante.

2. Pourquoi faire tourner une IA localement ?

Pas parce que « le cloud est mauvais ».

Et pas parce que ton ordinateur va soudain remplacer tous les meilleurs modèles disponibles.

L’intérêt est ailleurs.

🔐 1. Certaines données peuvent rester chez toi

Lorsque le modèle tourne localement, les prompts envoyés à ce modèle n’ont pas besoin d’être transmis à un fournisseur distant.

Cela peut être intéressant pour travailler sur :

Attention cependant :

utiliser un modèle local ne rend pas automatiquement toute ton installation privée.

Si ton agent utilise ensuite :

certaines données peuvent toujours quitter la machine.

Local ne signifie donc pas magiquement « aucune connexion extérieure ».

💸 2. Les générations locales ne sont pas facturées au token

Une fois le modèle téléchargé, tu ne paies pas chaque requête à une API.

Il reste évidemment un coût :

Mais pour certaines tâches répétitives, le local devient particulièrement intéressant.

Exemples :

3. Mais une IA locale est-elle aussi forte que ChatGPT ou Claude ?

Pas nécessairement.

Et c’est important de le dire.

Un petit modèle qui tourne tranquillement sur un ordinateur portable ne va pas automatiquement battre les meilleurs modèles exécutés dans des infrastructures contenant des centaines de GPU.

Il faut plutôt voir les choses ainsi :

IA CLOUD
très puissante
     ↓
pour les tâches difficiles

IA LOCALE
disponible + privée + peu coûteuse à utiliser
     ↓
pour les tâches courantes

Puis combiner les deux.

C’est souvent là que l’architecture devient intéressante.

4. L’installation que nous allons construire

Notre objectif sera très simple.

                 ┌── IA LOCALE
                 │
CODEX ─────── OLLAMA ─────── QWEN / GEMMA
                 │
                 │
                 └── ton ordinateur

Et éventuellement plus tard :

CODEX
 │
 ├── IA LOCALE → Ollama
 │
 └── IA CLOUD  → API

On obtient ainsi un environnement hybride.

Le petit travail quotidien peut rester local.

Et lorsqu’un problème demande davantage de puissance, tu peux utiliser un modèle distant.

5. Étape 1 : installer Ollama

Rends-toi sur :

👉 Télécharger Ollama

Ollama est disponible sur :

Sur Windows

L’installation se fait avec l’installateur Ollama classique et ne nécessite pas normalement de droits administrateur.

Sur macOS

Télécharge l’application puis place-la dans le dossier Applications.

Une fois installé, Ollama tourne en arrière-plan.

Tu viens essentiellement d’installer un petit moteur capable de faire fonctionner différents modèles IA.

Mais pour l’instant…

Il n’a encore aucun cerveau.

🧠❌

Il faut donc lui en donner un.

6. Étape 2 : installer ton premier modèle

Ouvre :

Puis tape :

ollama

Ollama possède désormais un menu permettant notamment de lancer et télécharger des modèles.

Mais nous allons également voir les commandes directement.

7. Quel modèle choisir ?

C’est probablement la partie qui effraie le plus lorsqu’on découvre l’IA locale.

7B.

20B.

32B.

Quantization.

MoE.

VRAM.

Q4_K_M.

Respire, le zoo est plus simple qu’il en a l’air. 😅

Pour commencer, retiens simplement ceci :

plus le modèle est gros, plus il demande généralement de ressources.

Ne commence donc pas par télécharger le monstre le plus imposant de la bibliothèque.

🟢 Option 1 : commencer léger

Gemma 3 4B

Gemma 3 est une famille de modèles ouverts de Google disponible notamment en versions 1B, 4B, 12B et 27B.

La variante 4B quantifiée distribuée sur Ollama pèse autour de 3,3 Go.

Télécharge-la avec :

ollama run gemma3:4b

C’est un bon moyen de vérifier simplement :

« Est-ce que mon ordinateur peut faire tourner un LLM correctement ? »

🟣 Option 2 : notre choix polyvalent

Qwen 3.5

Qwen propose plusieurs tailles de modèles et Ollama distribue notamment des variantes 0.8B, 2B, 4B, 9B, 27B et supérieures.

Pour tester :

ollama run qwen3.5:4b

ou, avec une machine plus confortable :

ollama run qwen3.5:9b

Le modèle Qwen 3.5 distribué par défaut par Ollama représente actuellement environ 6,6 Go et accepte également les images en entrée.

Pour un premier assistant local polyvalent, Qwen constitue une très bonne porte d’entrée.

🔵 Option 3 : pour aller plus loin

OpenAI distribue également des modèles open-weight GPT-OSS.

Par exemple :

ollama run gpt-oss:20b

La version GPT-OSS 20B distribuée par Ollama représente environ 14 Go. Elle est spécifiquement destinée au raisonnement et aux usages agentiques.

Ce n’est pas forcément le modèle par lequel commencer.

Mais il devient intéressant lorsque tu disposes d’une machine suffisamment puissante.

8. Testons notre IA locale

Une fois le modèle chargé, Ollama ouvre directement une conversation.

Essaie :

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

Puis :

Résume ce texte en cinq idées principales :

[TON TEXTE]

Et voilà.

Le texte est traité par le modèle fonctionnant sur ta machine.

Ton premier LLM local tourne.

🎉

9. Mais utiliser l’IA dans le terminal n’est pas très sexy

Exact.

Et c’est ici que le tuto devient beaucoup plus intéressant.

Nous allons lui donner une véritable interface de travail.

10. Étape 3 : installer Codex

Codex existe notamment sous forme d’application et de CLI.

👉 Documentation officielle de Codex

Codex est conçu comme un environnement agentique capable de travailler directement avec des projets et des fichiers locaux.

Mais Ollama possède désormais une intégration officielle avec Codex.

Et l’installation est presque ridiculement simple.

11. Connecter Ollama à Codex

Avec Ollama installé, ouvre ton terminal et tape :

ollama launch codex-app

Oui.

C’est presque tout.

Ollama documente officiellement cette commande pour configurer et lancer Codex App avec un modèle Ollama.

Tu peux également choisir explicitement le modèle :

ollama launch codex-app --model qwen3.5:9b

Ou :

ollama launch codex-app --model gpt-oss:20b

Ollama configure alors Codex pour communiquer avec son serveur local.

12. Ce qui vient de se passer

Avant :

TOI
 ↓
OLLAMA
 ↓
QWEN

Maintenant :

TOI
 ↓
CODEX
 ↓
OLLAMA
 ↓
QWEN

Codex devient l’atelier.

Ollama devient le moteur.

Qwen devient le cerveau.

13. Ton premier vrai test agentique

Crée un dossier sur ton ordinateur :

TEST-IA-LOCALE

Dedans, ajoute quelques fichiers texte ou Markdown.

Par exemple :

notes.md
idees.md
projet.md

Ouvre ensuite ce dossier dans Codex.

Essaie ce prompt :

Analyse tous les fichiers présents dans ce dossier.

Ne modifie rien pour le moment.

Explique-moi :

1. ce que contient le dossier ;
2. les principaux sujets ;
3. les informations répétées ;
4. les éventuelles contradictions ;
5. comment tu organiserais ces fichiers plus proprement.

Présente-moi ton plan avant toute modification.

L’intérêt devient immédiatement plus clair.

Tu n’es plus seulement en train de discuter avec un chatbot.

Tu donnes accès à un espace de travail.

14. Deuxième exercice : laisser l’agent créer quelque chose

Essaie ensuite :

À partir des fichiers présents dans ce dossier, crée un fichier nommé :

SYNTHESE.md

Il doit contenir :

# Synthèse

## Objectif du projet

## Informations importantes

## Idées principales

## Questions encore ouvertes

## Prochaines étapes

Ne supprime et ne modifie aucun fichier existant.

Ton modèle local peut maintenant contribuer directement à ton environnement de travail.

C’est là que la différence entre :

chatbot

et

agent

commence réellement à se voir.

15. Une excellente utilisation : travailler avec Obsidian

Si tu utilises Obsidian, le principe devient encore plus intéressant.

Ton vault est essentiellement un ensemble de fichiers Markdown.

Tu peux donc créer un dossier de test comme :

OBSIDIAN
│
├── SOURCES
├── NOTES
├── PROJETS
└── SYNTHESES

Puis demander :

Analyse uniquement le dossier SOURCES.

Pour chaque document :

- identifie le sujet principal ;
- extrais les informations importantes ;
- conserve les noms, chiffres et sources ;
- ne complète jamais une information absente ;
- crée une synthèse Markdown correspondante dans le dossier SYNTHESES.

Ne modifie jamais les fichiers originaux.

Tu viens de créer les prémices d’une petite chaîne documentaire locale assistée par IA.

16. Pourquoi Codex plutôt qu’une simple interface de chat ?

Parce qu’une IA locale devient beaucoup plus utile lorsqu’elle peut agir dans un environnement.

Une interface de chat classique fait :

toi → question → réponse

Un agent peut faire :

objectif
 ↓
observer
 ↓
lire les fichiers
 ↓
raisonner
 ↓
agir
 ↓
vérifier
 ↓
corriger

Pour :

cette différence est énorme.

17. Et Hermes ?

Hermes Agent est également très intéressant.

Ollama le référence d’ailleurs parmi ses intégrations d’assistants et agents.

Hermes est davantage orienté vers l’idée d’un agent autonome généraliste.

Sur le papier, cela peut être excellent pour :

Cependant, pour un premier tutoriel consacré au local, je recommande actuellement Codex.

Pourquoi ?

Parce que l’intégration :

ollama launch codex-app

est officiellement documentée et particulièrement simple.

Plusieurs problèmes récents ont en revanche été signalés concernant certaines combinaisons Hermes + Ollama, notamment autour du tool calling et de la gestion du contexte.

Hermes mérite donc plutôt un tutoriel niveau 2.

18. Attention au contexte avec les agents

Voici un détail technique qu’il faut malgré tout connaître.

Un modèle possède une fenêtre de contexte.

C’est en quelque sorte la taille de sa table de travail mentale.

Plus elle est grande, plus il peut garder simultanément :

Ollama recommande actuellement un contexte d’au moins 64 000 tokens pour les usages de type agents et outils de programmation comme Codex.

Mais augmenter le contexte demande également davantage de mémoire.

Pour débuter :

ne donne pas immédiatement 200 fichiers à ton agent.

Commence avec quelques documents.

Teste.

Puis augmente progressivement.

19. Ajouter une API gratuite comme roue de secours

Maintenant, construisons quelque chose d’encore plus intéressant.

Notre architecture locale fonctionne.

Mais imaginons que :

On peut conserver une porte vers le cloud.

Une possibilité particulièrement pratique pour expérimenter est OpenRouter.

OpenRouter fournit une API compatible avec le format OpenAI donnant accès à de nombreux modèles.

Et il existe aujourd’hui un routeur :

openrouter/free

qui sélectionne automatiquement parmi les modèles gratuits disponibles.

Le service indique actuellement un prix de :

0 $ / token

pour ce routeur gratuit, avec évidemment des limites d’utilisation.

20. L’architecture devient hybride

On peut alors imaginer :

                 ┌──────────────────┐
                 │      CODEX       │
                 └────────┬─────────┘
                          │
              ┌───────────┴───────────┐
              │                       │
          LOCAL                    CLOUD
              │                       │
           OLLAMA                OpenRouter
              │                       │
        Qwen / Gemma          modèles gratuits

Et plus tard :

TÂCHE SIMPLE
→ local

DONNÉES PRIVÉES
→ local

TRAITEMENT MASSIF
→ local

TÂCHE DIFFICILE
→ modèle cloud puissant

TEST / SECOURS
→ API gratuite

C’est probablement beaucoup plus intéressant que de penser :

local OU cloud.

Le véritable pouvoir se trouve souvent dans :

local ET cloud.

21. Le principe du routage intelligent

On peut même demander à l’agent de suivre une règle.

Par exemple :

Politique d'utilisation des modèles :

Utilise en priorité le modèle local pour :

- lecture de documents ;
- classification ;
- reformulation ;
- extraction ;
- Markdown ;
- organisation de fichiers ;
- tâches répétitives.

Utilise un modèle distant uniquement lorsque :

- la tâche nécessite un raisonnement complexe ;
- le modèle local échoue plusieurs fois ;
- une fonctionnalité requise n'est pas disponible localement.

Ne transmets jamais à une API distante un document marqué PRIVATE.

On commence alors à obtenir une véritable politique IA plutôt qu’un simple choix de chatbot.

22. Une autre utilisation intéressante : les traitements batch

Imaginons 500 fichiers Markdown.

Tu veux :

Avec une API payante :

500 fichiers
×
tokens entrants
×
tokens sortants
=
facturation

Avec un modèle local :

500 fichiers
×
temps machine
=
pas de facturation au token

Pour ce genre de travail répétitif, le local peut devenir particulièrement intéressant.

23. Ce qu’une petite IA locale fait très bien

Ne cherche pas immédiatement à lui faire résoudre les mystères de l’univers.

Commence par lui confier le travail de bureau numérique.

🟢 Très bon usage

Résume ces documents.

🟢 Très bon usage

Classe ces fichiers.

🟢 Très bon usage

Transforme ces notes en Markdown structuré.

🟢 Très bon usage

Extrais les noms, dates et organisations.

🟢 Très bon usage

Compare ces trois documents.

🟢 Très bon usage

Renomme ces fichiers selon cette convention.

🟢 Très bon usage

Analyse mon projet et crée un sommaire.

Ce sont précisément ces petites tâches qui peuvent représenter énormément de tokens lorsqu’elles sont répétées quotidiennement.

24. Ce que je conserverais dans le cloud

Je garderais encore les meilleurs modèles distants pour certaines tâches.

Par exemple :

La bonne architecture n’est donc pas :

☁️ CLOUD = MAL
🏠 LOCAL = BIEN

Ce serait un peu trop facile.

Elle ressemble plutôt à :

BON OUTIL
    ↓
BON ENDROIT
    ↓
BONNE TÂCHE

25. Le setup minimum que je recommande

Pour quelqu’un qui veut simplement découvrir l’IA locale :

Étape 1

Installer :

👉 Ollama

Étape 2

Tester :

ollama run qwen3.5:4b

ou :

ollama run gemma3:4b

Étape 3

Installer :

👉 Codex

Étape 4

Connecter les deux :

ollama launch codex-app

Étape 5

Créer :

TEST-IA-LOCALE

Étape 6

Ajouter trois fichiers Markdown.

Étape 7

Demander :

Analyse ce dossier.

Explique-moi son contenu.

Ne modifie rien sans mon autorisation.

C’est tout.

Pas de serveur.

Pas de Docker.

Pas de Python.

Pas de clé API.

Pas de déploiement Kubernetes dans la cuisine.

🧑‍🍳

26. Puis seulement après, améliorer le laboratoire

Une fois cette première expérience maîtrisée, tu peux ajouter progressivement :

NIVEAU 1
Ollama + modèle

        ↓

NIVEAU 2
Ollama + Codex

        ↓

NIVEAU 3
Ollama + Obsidian

        ↓

NIVEAU 4
API gratuite / OpenRouter

        ↓

NIVEAU 5
RAG + embeddings

        ↓

NIVEAU 6
Hermes / agents spécialisés

        ↓

NIVEAU 7
automatisations

Ne construis pas le niveau 7 lorsque tu n’as jamais testé le niveau 1.

C’est la meilleure manière de passer trois heures à configurer une magnifique usine qui ne fabrique encore absolument rien.

27. Prompt prêt à copier : faire découvrir ton dossier à l’IA

Tu travailles comme assistant documentaire.

Commence par analyser le dossier actuel.

Ne modifie aucun fichier.

Identifie :

1. les dossiers présents ;
2. les types de fichiers ;
3. les principaux sujets ;
4. les éventuels doublons ;
5. les informations importantes ;
6. les problèmes d'organisation.

Propose ensuite une organisation améliorée.

IMPORTANT :

Ne déplace, renomme, supprime ou modifie aucun fichier avant que je valide ton plan.

28. Prompt : transformer l’IA locale en bibliothécaire

Tu es chargé d'organiser cette bibliothèque documentaire.

Ton rôle est de :

- lire les documents ;
- comprendre leur sujet ;
- identifier les informations importantes ;
- détecter les doublons ;
- proposer des tags ;
- créer des liens logiques entre les documents.

Règles :

- ne jamais inventer une information absente ;
- conserver les sources ;
- conserver les dates ;
- ne jamais supprimer un fichier ;
- demander confirmation avant toute modification importante ;
- privilégier Markdown.

Commence uniquement par analyser la bibliothèque et proposer un plan.

29. Prompt : utiliser l’IA locale pour Obsidian

Tu travailles dans un vault Obsidian.

Respecte les fichiers Markdown existants.

Pour chaque nouveau document créé :

- utiliser un titre H1 ;
- créer des sections claires ;
- conserver les sources ;
- utiliser les liens internes [[Nom de la note]] lorsque pertinent ;
- ajouter quelques tags utiles ;
- ne jamais inventer de données manquantes.

Avant toute modification importante de l'arborescence, présente-moi ton plan.

30. Prompt : audit d’un projet

Analyse l'intégralité de ce projet.

Ne modifie aucun fichier.

Je veux comprendre :

- son objectif ;
- sa structure ;
- les fichiers importants ;
- les fichiers probablement obsolètes ;
- les dépendances ;
- les problèmes éventuels ;
- les améliorations possibles.

Explique le projet comme si tu devais le transmettre demain à une nouvelle personne.

Termine par :

## Priorité haute
## Priorité moyenne
## Priorité basse

31. Ce que nous avons réellement construit

Nous n’avons pas simplement « installé Qwen ».

Nous avons créé une petite architecture IA personnelle.

                    TOI
                     │
                     ▼
                ┌─────────┐
                │ CODEX   │
                └────┬────┘
                     │
                     ▼
                ┌─────────┐
                │ OLLAMA  │
                └────┬────┘
                     │
                     ▼
              ┌──────────────┐
              │ MODÈLE LOCAL │
              │ Qwen / Gemma │
              └──────────────┘
                     │
                     ▼
              TES FICHIERS

Et éventuellement :

                     │
                     └────→ API CLOUD

C’est une base.

Mais une base étonnamment puissante.

Conclusion

L’IA locale a longtemps ressemblé à un territoire réservé aux développeurs capables de réciter les références de leur GPU avant le petit-déjeuner.

Ce n’est progressivement plus le cas.

Aujourd’hui, pour découvrir le principe, quelques étapes suffisent :

Installer Ollama
        ↓
Télécharger un modèle
        ↓
Installer Codex
        ↓
Connecter les deux
        ↓
Ouvrir un dossier
        ↓
Travailler

Tu n’obtiendras pas nécessairement le modèle le plus puissant de la planète.

Mais tu obtiens quelque chose de différent :

un modèle que tu peux faire tourner chez toi, intégrer à tes outils et utiliser sans compteur de tokens à chaque requête.

Ensuite vient la partie réellement intéressante.

Décider intelligemment ce qui doit rester :

🏠 local

et ce qui mérite encore :

☁️ le cloud.

Parce que posséder un marteau ne signifie pas qu’il faut démonter toute la maison avec.

Mais c’est plutôt agréable d’avoir enfin quelques outils dans son propre garage numérique.