20 Sep 2026 · 5 min de lecture
Développer avec un LLM sans API : faire tourner un modèle en local
Un modèle qui tourne sur votre machine ignore les listes de pays, les cartes internationales et les VPN — et continue de fonctionner quand la connexion tombe. Matériel nécessaire, intégration Django propre, et limites assumées.
Quand une API d'IA n'est pas disponible dans votre pays, la réponse réflexe est de chercher à contourner la restriction. Il y a une autre voie, plus solide : ne pas dépendre d'une API du tout.
Un modèle de langage qui tourne sur votre propre machine ne connaît ni liste de pays supportés, ni carte bancaire internationale, ni VPN. Il fonctionne aussi quand la connexion tombe — ce qui, à Kinshasa, n'est pas un détail théorique.
Voici comment je m'en sers en production, et surtout ce que ça ne remplace pas.
Ce qu'il faut comme machine
C'est la première question, et la réponse a beaucoup changé en deux ans. Les modèles de 3 à 8 milliards de paramètres atteignent aujourd'hui une qualité qui demandait 30 milliards en 2024.
Concrètement, avec une quantification Q4_K_M — le compromis standard entre qualité et mémoire :
| RAM disponible | Taille de modèle réaliste |
|---|---|
| 8 Go | 7B (minimum viable, sans GPU) |
| 16 Go | 13B–14B |
| 24 Go et plus | 32B |
Un modèle 7B quantifié occupe environ 4 à 5 Go, auxquels s'ajoutent 1 à 2 Go pour le cache de contexte et le système. Un GPU n'est pas obligatoire : un processeur 64 bits récent suffit pour démarrer, simplement plus lentement. Avec 16 Go de RAM et un GPU de 8 à 12 Go, on atteint des vitesses confortables pour un usage quotidien.
Autrement dit : un ordinateur de développeur correct suffit. Pas besoin d'une station à plusieurs milliers de dollars.
Installer et lancer
Ollama est le chemin le plus court. Installation, puis :
ollama pull qwen3.5:4b # léger, bon rapport qualité/mémoire
ollama run qwen3.5:4b # test interactif immédiat
Le serveur écoute ensuite sur http://localhost:11434.
Les noms de modèles bougent vite — vérifiez la bibliothèque courante plutôt que de recopier un tutoriel de l'an dernier. Les familles à regarder en priorité aujourd'hui : Qwen, Llama, Mistral Small et Phi.
L'intégrer dans Django proprement
C'est ici que la plupart des tutoriels s'arrêtent, et c'est là que les vrais problèmes commencent. Une génération locale prend de quelques secondes à plusieurs dizaines de secondes : appeler le modèle directement dans une vue, c'est bloquer un worker Gunicorn pendant tout ce temps.
Un service isolé, avec délai d'attente explicite :
# ai/services.py
import requests
from django.conf import settings
OLLAMA_URL = getattr(settings, "OLLAMA_URL", "http://localhost:11434")
MODEL = getattr(settings, "OLLAMA_MODEL", "qwen3.5:4b")
class ModelUnavailable(Exception):
"""Le serveur local ne répond pas : à traiter comme une panne réseau."""
def generate(prompt, *, system="", timeout=120):
try:
response = requests.post(
f"{OLLAMA_URL}/api/chat",
json={
"model": MODEL,
"stream": False,
"messages": (
([{"role": "system", "content": system}] if system else [])
+ [{"role": "user", "content": prompt}]
),
},
timeout=timeout,
)
response.raise_for_status()
except requests.RequestException as exc:
raise ModelUnavailable(str(exc)) from exc
return response.json()["message"]["content"]
Puis une tâche Celery, pour que l'utilisateur ne regarde pas une page figée :
# ai/tasks.py
from celery import shared_task
from .services import ModelUnavailable, generate
@shared_task(bind=True, max_retries=3, default_retry_delay=10)
def summarize(self, document_id):
from .models import Document
document = Document.objects.get(pk=document_id)
try:
document.summary = generate(
document.body[:8000],
system="Résume ce texte en cinq puces factuelles, en français.",
)
except ModelUnavailable as exc:
raise self.retry(exc=exc)
document.save(update_fields=["summary"])
Trois réflexes qui font la différence :
Tronquer l'entrée. Un contexte de 8 000 caractères traité localement est déjà confortable. Envoyer un document entier multiplie le temps de génération sans améliorer le résultat.
Traiter l'indisponibilité comme une panne réseau. Le serveur local peut être arrêté, saturé, ou en cours de chargement de modèle. ModelUnavailable + retry Celery, exactement comme pour un webhook de paiement.
Mettre en cache les résultats déterministes. Si la même entrée revient, ne régénérez pas : le coût n'est pas en argent ici, il est en temps processeur et en batterie.
Ce que le local ne remplace pas
Soyons honnêtes, sinon l'article ne vaut rien.
Un modèle 7B local ne rivalise pas avec un modèle de frontière sur du raisonnement complexe, du code long ou de l'analyse fine. Ce n'est pas le même outil.
Là où il excelle en revanche — et c'est l'essentiel des besoins réels d'une application métier :
- classification et étiquetage (tickets, messages, documents)
- extraction structurée depuis du texte libre
- résumés et reformulations
- brouillons de réponses à faire relire par un humain
- recherche sémantique, via les embeddings
Pour ces usages, la différence de qualité avec un modèle hébergé est faible, et l'indépendance totale.
Le vrai argument
On parle beaucoup de confidentialité et de coût, qui sont de bons arguments. Mais celui qui compte le plus ici est ailleurs : c'est une infrastructure que personne ne peut vous retirer. Pas de liste de pays, pas de conditions d'utilisation qui changent, pas de moyen de paiement à faire valider à l'étranger.
Quand on développe depuis un pays que les fournisseurs n'ont pas encore inscrit sur leurs listes, cette propriété-là vaut plus que quelques points de performance.
Le contexte de cette question est détaillé dans mon article sur l'accès aux outils d'IA depuis la RDC.
Écrit par
Josué Dikoma — Ingénieur full stack et DevSecOps polyvalent