Travailler sans Internet : 4 IA locales qui travaillent à la chaîne

Pourquoi prévoir un mode dégradé

J’utilise une IA en ligne pour mes projets perso, le soir et le week-end : coder, rédiger, faire du SEO sur mes sites. Le jour où la box lâche, tout s’arrête. Une coupure Internet ne doit plus bloquer mes projets.

J’avais déjà installé une IA locale pour coder (Qwen 2.5 Coder 3B avec Ollama). Cette fois, je suis allé plus loin : un petit panel de 4 modèles, chacun avec son rôle, qui travaillent l’un après l’autre sur la même tâche.

Le résultat n’égale pas une IA en ligne. Mais il permet de continuer à avancer en mode dégradé, gratuitement et sans qu’aucune donnée ne quitte mon PC.

Ma configuration : 4 Go de VRAM, la vraie limite

Composant Modèle
Processeur Intel Core i5-11400F (6 cœurs, 12 threads)
Mémoire vive 32 Go
Carte graphique NVIDIA GTX 1650 Super, 4 Go de VRAM
Système Windows, avec Ollama et VS Code

C’est la mémoire de la carte graphique qui décide de tout. Un modèle qui tient entièrement dans les 4 Go répond vite. S’il déborde, une partie passe sur le processeur et la vitesse chute.

Deux règles en découlent :

  • des modèles de 2 à 4 milliards de paramètres pour le travail courant ;
  • un seul modèle chargé à la fois, pour ne jamais saturer la carte graphique.

Les 4 modèles et le rôle de chacun

Chaque modèle a un point fort, et la chaîne les combine.

Modèle Commande Ollama Rôle dans la chaîne Pourquoi lui
Qwen 3.5 4B qwen3.5:4b Planifier, puis finaliser Le meilleur raisonnement à cette taille, avec un mode « réflexion » activable
Gemma 4 E2B gemma4:e2b Rédiger Léger, à l’aise en rédaction, et lit aussi les images
Phi-4 Mini phi4-mini Relire et critiquer Entraîné sur la logique : un regard différent des Qwen
Qwen 3.5 9B qwen3.5:9b Renfort pour les tâches difficiles Plus intelligent, mais déborde de la carte : plus lent

J’ai gardé Qwen 2.5 Coder 3B pour l’autocomplétion dans VS Code, et ajouté nomic-embed-text, un petit modèle qui sert à chercher dans le code d’un projet.

Installer les modèles en une commande

Avec Ollama déjà installé, une seule ligne PowerShell télécharge tout le panel :

"qwen3.5:4b", "gemma4:e2b", "phi4-mini", "qwen3.5:9b", "nomic-embed-text" | ForEach-Object { ollama pull $_ }

Il faut prévoir une quinzaine de Go d’espace disque. Si le téléchargement s’interrompt, il suffit de relancer la commande : les modèles déjà présents ne sont pas retéléchargés.

Pour vérifier que tout est là :

ollama list

À faire avant la panne : ce téléchargement demande Internet. Le mode dégradé se prépare quand tout fonctionne.

Des réponses directes, sans plan

En mode réflexion, Qwen 3.5 écrit un long raisonnement avant de répondre. Pour un usage courant, j’ai créé une variante qui répond directement :

@"
FROM qwen3.5:4b
SYSTEM "Réponds en français, directement et brièvement. Pas de plan, pas d'introduction."
"@ | Out-File -Encoding utf8 Modelfile

ollama create qwen-rapide -f Modelfile
ollama run qwen-rapide --think=false

Faire travailler les IA l’une après l’autre

Un petit script Python passe la tâche d’un modèle à l’autre, et retire chaque modèle de la carte graphique dès qu’il a fini. Il n’y en a donc jamais deux en mémoire en même temps.

La chaîne suit quatre étapes :

  1. Qwen 3.5 4B découpe la demande en un plan court.
  2. Gemma 4 E2B rédige en suivant ce plan.
  3. Phi-4 Mini relit et liste les erreurs et les oublis.
  4. Qwen 3.5 4B corrige le texte à partir de la critique et rend la version finale.

Chaque modèle reçoit le travail des précédents. Le résultat complet est enregistré dans un fichier resultat.md.

Le script

Il n’utilise que Python standard : rien à installer en plus. Deux paramètres font tout le travail : keep_alive: 0 libère la carte graphique après chaque réponse, et think: False évite les longs raisonnements.

import json, sys, urllib.request

OLLAMA_URL = "http://localhost:11434/api/chat"

ETAPES = [
    ("Planificateur", "qwen3.5:4b",
     "Tu es un planificateur. Découpe la demande en un plan court et concret (5 points max)."),
    ("Rédacteur", "gemma4:e2b",
     "Tu es un rédacteur. Produis le travail demandé en suivant le plan fourni."),
    ("Critique", "phi4-mini",
     "Tu es un relecteur exigeant. Liste les erreurs, oublis et améliorations possibles. Sois bref."),
    ("Finaliseur", "qwen3.5:4b",
     "Tu es l'éditeur final. Corrige le travail en tenant compte de la critique. "
     "Rends uniquement la version finale."),
]

def appeler(modele, systeme, message):
    corps = json.dumps({
        "model": modele,
        "messages": [
            {"role": "system", "content": systeme + " Réponds en français."},
            {"role": "user", "content": message},
        ],
        "stream": False,
        "think": False,
        "keep_alive": 0,
    }).encode("utf-8")
    req = urllib.request.Request(OLLAMA_URL, data=corps,
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=900) as rep:
        return json.loads(rep.read())["message"]["content"].strip()

demande = sys.argv[1]
contexte = f"DEMANDE :\n{demande}"
resultats = {}
for nom, modele, role in ETAPES:
    print(f"\n=== {nom} ({modele}) en cours... ===")
    reponse = appeler(modele, role, contexte)
    resultats[nom] = reponse
    print(reponse)
    contexte += f"\n\n--- {nom.upper()} ---\n{reponse}"

with open("resultat.md", "w", encoding="utf-8") as f:
    f.write(f"# Demande\n{demande}\n\n")
    for nom, texte in resultats.items():
        f.write(f"## {nom}\n{texte}\n\n")

Le lancer

py agents.py "Rédige un article de 600 mots sur la location de photobooth pour un mariage"

Pour changer de chaîne, il suffit de modifier la liste ETAPES : ajouter une étape, changer un rôle, ou confier la finalisation à qwen3.5:9b pour gagner en qualité.

Les mêmes modèles dans VS Code

Dans VS Code, l’extension Continue utilise les modèles d’Ollama sans connexion. J’y ai réparti les rôles : le petit modèle de code pour l’autocomplétion, Qwen 3.5 pour le chat.

Fichier config.yaml de Continue (dans %USERPROFILE%\.continue\) :

name: IA locale
version: 1.0.0
schema: v1
models:
  - name: Qwen Coder 3B (local)
    provider: ollama
    model: qwen2.5-coder:3b
    roles:
      - autocomplete
      - apply
  - name: Qwen Rapide
    provider: ollama
    model: qwen-rapide
    roles:
      - chat
      - edit
  - name: Nomic Embed
    provider: ollama
    model: nomic-embed-text
    roles:
      - embed

Avec nomic-embed-text, Continue peut aussi chercher dans tout le projet avec @codebase.

Ce que ça donne, et les limites

Le mode dégradé tient ses promesses : je peux continuer à coder, rédiger et structurer du contenu pour mes projets perso pendant une coupure. Mais il faut accepter un niveau en dessous d’une IA en ligne.

Ce qui marche bien

  • Comprendre et déboguer un bout de code, une règle .htaccess, une requête SQL.
  • Produire un premier jet d’article, des balises title et meta, une structure de Hn.
  • Reformuler un texte ou un mail.
  • Travailler sur des contenus confidentiels : rien ne sort du PC.

Les limites

  • Vitesse : la chaîne enchaîne quatre modèles et les recharge à chaque étape. Sur ma machine, la chaîne complète a mis 6 min 55 s pour produire un article d’environ 1000 mots.
  • Mode réflexion : activé, il rend Qwen nettement plus lent. Je le réserve aux questions difficiles.
  • Connaissances : ces petits modèles inventent facilement des faits, et n’ont aucune info récente. Tout ce qui est factuel se vérifie une fois la connexion revenue.
  • Contexte : avec 4 Go de VRAM, impossible de leur donner de longs documents.

Mes conseils

  • Tout installer et tester avant d’en avoir besoin.
  • Vérifier avec ollama ps que le modèle tourne à 100 % sur la carte graphique.
  • Fermer les jeux et le navigateur pendant que la chaîne tourne, pour libérer la VRAM.

Le test : j’ai fait écrire cet article par mes IA locales

La chaîne a tenu techniquement, mais le texte produit n’était pas publiable. J’ai donné aux 4 modèles un seul sujet : écrire un article de 1000 mots sur cette installation. Ils ont mis 6 min 55 s, l’un après l’autre, sans saturer la carte graphique.

Les rôles n’ont pas été respectés

  • Le planificateur a rédigé l’article entier au lieu d’un plan.
  • La critique a tout réécrit au lieu de lister les problèmes.
  • Le finaliseur a commenté le texte au lieu de rendre la version finale.

Des inventions techniques

  • Un « protocole LLM-STD » qui n’existe pas.
  • Une option --numba qui n’existe pas non plus.
  • « Q4 impossible sur 4 Go » : faux, mon Qwen 4B tourne justement en Q4.
  • « Ollama enchaîne les étapes tout seul » : faux, c’est mon script qui le fait.
  • Une « semaine de panne » que je n’ai jamais vécue.

Des connaissances dépassées : le finaliseur, lui-même un Qwen 3.5, a affirmé que Gemma 4 et Qwen 3.5 « n’existent pas encore ». Ses connaissances s’arrêtent avant leur sortie.

Pourquoi

Je leur avais donné un sujet, pas les faits. Un petit modèle qui ne sait pas comble les trous en inventant. Des consignes de rôle trop souples et un historique de plus en plus long ont fait le reste.

Ce que j’en retiens

Moi j’apporte les faits, l’IA locale les met en forme.

Mon IA locale est fiable pour Elle n’est pas fiable pour
Reformuler ou raccourcir un texte que j’ai écrit Écrire un article à partir d’un simple sujet
Structurer mes notes en paragraphes et intertitres Parler de technique récente
Proposer des title, meta descriptions et Hn Respecter des rôles complexes dans une chaîne
Relire l’orthographe et les tournures Donner des faits sans vérification
Comprendre et déboguer du code

FAQ

Faut-il une grosse carte graphique pour faire tourner plusieurs IA locales ?

Non. En les faisant travailler l’une après l’autre, une carte de 4 Go suffit, car un seul modèle est chargé à la fois.

Les IA locales fonctionnent-elles vraiment sans Internet ?

Oui. Une fois les modèles téléchargés, Ollama, Continue et le script tournent entièrement hors ligne.

Pourquoi utiliser plusieurs modèles plutôt qu’un seul ?

Chaque petit modèle a ses points forts. Les faire se relire entre eux corrige une partie des erreurs qu’un modèle seul laisserait passer.

Est-ce que ça remplace une IA en ligne ?

Non. C’est un mode dégradé : utile pour continuer à avancer, mais moins rapide et moins fiable.

Combien d’espace disque faut-il ?

Environ 15 Go pour les cinq modèles présentés ici.

Conclusion

Avec quatre petits modèles, Ollama et un script d’une cinquantaine de lignes, une coupure Internet ne bloque plus mes projets perso. Le résultat reste en dessous d’une IA en ligne, mais il est gratuit, privé et toujours disponible. Deux leçons : tout préparer avant la panne, et rester l’auteur. Pendant une coupure, l’IA locale est une assistante de rédaction, pas une rédactrice.