Skip to main content
PromptQuorumBuilt for humans. Structured for AI.
Accueil/LLM locaux avancés
Overview & Reference

LocalAI expliqué : l'alternative auto-hébergée à l'API OpenAI (2026)

·12 min de lecturePar Hans Kuepper · Fondateur de PromptQuorum · Moteur de découverte de l'IA open-weight et open source

LocalAI est un moteur d'IA gratuit, sous licence MIT et auto-hébergé, qui expose une API compatible OpenAI (plus des points de terminaison compatibles Anthropic et ElevenLabs) devant un ensemble modulaire de backends d'inférence chargés indépendamment. Au lieu d'embarquer un seul moteur d'inférence figé, son noyau route chaque requête vers un processus backend interchangeable — llama.cpp et vLLM pour le texte, des backends basés sur diffusers pour la génération d'image, des backends basés sur whisper.cpp pour la transcription, et d'autres pour la synthèse vocale et les embeddings — si bien qu'une seule instance auto-hébergée peut couvrir plusieurs modalités qui nécessiteraient sinon des outils séparés. Il fonctionne uniquement sur CPU sans GPU requis, ou avec accélération NVIDIA CUDA, AMD ROCm, Intel ou Vulkan, et est distribué sous forme d'images Docker, d'un installeur macOS et d'un binaire CLI.

Points clés

  • Gratuit et sous licence MIT, créé par Ettore Di Giacinto ("mudler") et maintenu sur github.com/mudler/LocalAI
  • API compatible OpenAI en remplacement direct, plus des points de terminaison compatibles Anthropic et ElevenLabs
  • Un noyau léger route les requêtes vers des backends chargés indépendamment plutôt que d'embarquer un moteur d'inférence fixe
  • Les backends documentés par le projet incluent llama.cpp et vLLM pour le texte, des backends basés sur diffusers pour la génération d'image et des backends basés sur whisper.cpp pour la transcription
  • Couvre génération de texte, génération d'image, transcription, synthèse vocale et embeddings depuis une seule instance
  • Fonctionne uniquement sur CPU sans GPU requis, ou avec accélération NVIDIA CUDA, AMD ROCm, Intel ou Vulkan
  • Distribué sous forme d'images Docker (variantes CPU et GPU), d'un installeur macOS et d'un binaire CLI ; le déploiement Kubernetes est documenté
  • Pas un moteur d'inférence brut concurrent — il charge des moteurs comme llama.cpp et vLLM comme backends plutôt que de les remplacer

📍 En une phrase

LocalAI est un moteur gratuit, sous licence MIT et auto-hébergé, qui expose une API compatible OpenAI devant des backends interchangeables — dont llama.cpp, vLLM, diffusers et whisper.cpp — couvrant texte, image et audio depuis une seule instance.

💬 En termes simples

Au lieu d'une appli pour discuter, une autre pour générer des images et une autre pour transcrire, LocalAI est un unique serveur auto-hébergé qui parle la même API qu'OpenAI, si bien que du code client OpenAI existant peut pointer dessus pendant qu'il délègue discrètement chaque requête au moteur qui gère réellement cette tâche.

📌Remarque: Cet article s'appuie sur le dépôt GitHub officiel de LocalAI et sa documentation publique, pas sur des benchmarks indépendants. Il évite les affirmations de fonctionnalités liées à une version précise et les chiffres de performance, car LocalAI publie des versions fréquentes et aucun des deux n'a été mesuré indépendamment pour cet article.

Lire en:
🇺🇸en🇩🇪de🇫🇷fr🇯🇵ja🇨🇳zh🇪🇸es🇧🇷pt🇸🇦ar🇰🇷ko

LocalAI est un moteur d'IA gratuit, sous licence MIT et auto-hébergé, créé par Ettore Di Giacinto ("mudler") et maintenu par une communauté open-source sur github.com/mudler/LocalAI. Il expose une API compatible OpenAI en remplacement direct (plus des points de terminaison compatibles Anthropic et ElevenLabs) devant un ensemble modulaire de backends chargés indépendamment, si bien qu'une seule instance peut couvrir la génération de texte, la génération d'image, la transcription audio, la synthèse vocale et les embeddings au lieu de nécessiter un outil séparé par modalité. LocalAI ne remplace pas des moteurs comme llama.cpp ou vLLM — il peut charger l'un ou l'autre (et d'autres) comme backend, agissant comme une couche d'orchestration et de compatibilité API plutôt que comme un moteur d'inférence concurrent.

LocalAI expliqué : l'alternative auto-hébergée à l'API OpenAI (2026)

Qu'est-ce que LocalAI ?

LocalAI est un moteur d'IA gratuit, sous licence MIT et auto-hébergé, qui permet d'exécuter des modèles de texte, d'image et audio compatibles avec l'API OpenAI sur son propre matériel. Il a été créé par Ettore Di Giacinto, connu sous le nom de "mudler" sur GitHub, et est aujourd'hui maintenu par une communauté open-source. Le projet décrit son objectif comme l'exécution de modèles sur plusieurs modalités sur n'importe quel matériel, sans qu'un GPU soit strictement requis.

  • Créé par Ettore Di Giacinto ("mudler") ; code source et documentation sur github.com/mudler/LocalAI
  • Sous licence MIT : utilisation, modification et auto-hébergement libres, y compris à des fins commerciales, dans le cadre de la licence
  • Expose un serveur compatible API OpenAI, plus des points de terminaison compatibles Anthropic et ElevenLabs documentés, si bien que du code client existant écrit pour ces API peut souvent pointer vers une instance LocalAI auto-hébergée
  • Se positionne sur l'étendue des modalités plutôt que sur la vitesse maximale d'une seule — texte, image et audio depuis un seul déploiement
  • Distinct d'un moteur d'inférence unique : son propre noyau gère le routage des requêtes et la compatibilité API, tandis que l'exécution du modèle a lieu dans des processus backend séparés

Comment fonctionne l'architecture de backends de LocalAI ?

Le noyau de LocalAI est un routeur léger, pas un moteur d'inférence monolithique — il reçoit une requête compatible OpenAI, détermine le modèle et le backend auxquels elle correspond, puis communique avec un processus backend séparé pour exécuter réellement l'inférence.

  • Le processus principal gère la compatibilité API, le routage des requêtes et la configuration des modèles, puis communique avec les processus backend via gRPC
  • Les backends documentés par le projet incluent llama.cpp et vLLM pour la génération de texte, des backends basés sur diffusers pour la génération d'image, et des backends basés sur whisper.cpp pour la transcription
  • Les backends peuvent être installés depuis une galerie de modèles/backends, ou configurés manuellement via un fichier YAML pointant vers un backend et un modèle spécifiques
  • Comme les backends sont des composants installables séparés, un déploiement n'a besoin de charger que les backends réellement requis par son cas d'usage, plutôt que d'embarquer tous les moteurs possibles par défaut
  • Le projet développe aussi lui-même certains backends natifs en plus d'intégrer des moteurs existants

Que peut faire LocalAI au-delà de la génération de texte ?

Le périmètre documenté de LocalAI couvre davantage de modalités que des moteurs texte seul comme llama.cpp ou vLLM, ce qui constitue sa principale différence par rapport à ces outils.

Génération de texte

Backend type:
llama.cpp, vLLM — points de terminaison chat/completions

Génération d'image

Backend type:
Backends basés sur diffusers (type Stable Diffusion)

Transcription (STT)

Backend type:
Backends basés sur whisper.cpp

Synthèse vocale (TTS)

Backend type:
Backends TTS dédiés documentés par le projet

Embeddings

Backend type:
Backends de modèles d'embedding dédiés

Chaque ligne ci-dessus correspond à un backend séparé qui doit être installé pour que cette modalité fonctionne — installer LocalAI seul n'active pas automatiquement toutes les modalités. Les noms exacts des backends et leur couverture évoluent selon les versions ; la galerie propre au projet fait foi plutôt qu'une liste figée.

Quelle configuration matérielle pour LocalAI ?

LocalAI se positionne, selon sa documentation, comme fonctionnant sur n'importe quel matériel, sans GPU strictement requis — la même instance peut tourner uniquement sur CPU pour des charges plus légères, ou utiliser l'accélération GPU si disponible pour des modèles plus grands.

CPU uniquement

Détails:
Documenté comme entièrement pris en charge sans GPU requis, avec des backends optimisés CPU comme llama.cpp pour le texte.

GPU NVIDIA (CUDA)

Détails:
Des images Docker dédiées CUDA sont publiées ; l'accélération est utilisée par les backends compatibles quand un GPU pris en charge est présent.

GPU AMD (ROCm)

Détails:
Une image Docker ROCm/hipBLAS est publiée comme voie d'accélération AMD documentée.

GPU Intel (oneAPI)

Détails:
Une image Docker Intel dédiée est publiée pour l'accélération GPU Intel.

Vulkan

Détails:
Une image Docker Vulkan est publiée comme option d'accélération GPU multi-constructeurs.

Apple Silicon (Mac)

Détails:
Un installeur macOS natif est publié ; des backends accélérés Metal sont documentés pour les Mac Apple Silicon.

La taille de modèle réellement exploitable et la vitesse dépendent toujours de la RAM/VRAM disponible et du backend utilisé par un modèle donné, comme pour llama.cpp ou vLLM directement — le positionnement « sans GPU requis » de LocalAI décrit le fait que le chemin CPU seul est entièrement pris en charge, pas que chaque modèle ou backend fonctionne aussi bien sans GPU.

Comment installer et lancer LocalAI ?

Le chemin le plus rapide documenté par LocalAI est Docker, avec une image CPU seule et des tags d'image accélérés GPU distincts selon le matériel.

  1. 1
    Installer Docker si ce n'est pas déjà fait, puis choisir une image CPU seule ou un tag d'image GPU adapté à son matériel.
  2. 2
    Pour un usage CPU seul, exécuter : docker run -p 8080:8080 --name local-ai -ti localai/localai:latest.
  3. 3
    Pour des GPU NVIDIA, utiliser plutôt une image CUDA, par exemple localai/localai:latest-gpu-nvidia-cuda-12, en ajoutant --gpus all à la commande Docker.
  4. 4
    Pour des GPU AMD, Intel ou Vulkan, utiliser le tag d'image -gpu-hipblas, -gpu-intel ou -gpu-vulkan correspondant, documenté par le projet.
  5. 5
    Une fois le conteneur lancé, LocalAI écoute par défaut sur le port 8080.
  6. 6
    Installer un modèle via la CLI (local-ai models install <name>) ou la galerie de modèles de l'interface web, ou en lancer un directement avec local-ai run <name>, qui le télécharge d'abord si besoin.
  7. 7
    Envoyer sa première requête au point de terminaison compatible OpenAI : `curl http://localhost:8080/v1/chat/completions -H "Content-Type: application/json" -d '{"model": "<nom-du-modele-installe>", "messages": [{"role": "user", "content": "Bonjour !"}]}'`.
  8. 8
    Pointer le code client OpenAI existant vers son instance auto-hébergée en changeant uniquement l'URL de base et le nom du modèle.

Faut-il un GPU pour faire tourner LocalAI ?

Non — LocalAI est documenté comme fonctionnant uniquement sur CPU sans GPU requis, et publie séparément des tags d'images Docker accélérées GPU pour le matériel NVIDIA, AMD, Intel et Vulkan pour les configurations qui en disposent.

D'où viennent les modèles de LocalAI ?

Le projet documente plusieurs sources : sa propre galerie de modèles (installable via la CLI ou l'interface web), des dépôts Hugging Face, des références au format Ollama, des URL de configuration YAML directes et des images OCI.

Comment LocalAI se compare-t-il à Ollama ?

LocalAI et Ollama facilitent tous deux l'auto-hébergement de modèles derrière une API simple, mais visent des périmètres différents : Ollama est conçu autour d'un chemin rapide et minimal, mono-utilisateur, pour des modèles de texte (et un peu de vision), tandis que LocalAI mise sur une couverture de modalités plus large et une compatibilité API OpenAI/Anthropic/ElevenLabs pour le texte, l'image et l'audio.

  • Ollama se concentre surtout sur des modèles de texte (et un peu de vision), avec une installation et un téléchargement de modèle en une commande, pensés pour une configuration mono-utilisateur rapide
  • LocalAI documente une couverture de modalités plus large en un seul déploiement — texte, génération d'image, transcription et synthèse vocale — en chargeant des backends différents pour chacune
  • LocalAI documente une compatibilité en remplacement direct avec trois formats d'API (OpenAI, Anthropic, ElevenLabs) ; l'interface principale d'Ollama est sa propre API, avec une couche de compatibilité OpenAI séparée
  • LocalAI peut charger des références de modèles au format Ollama (ollama://) comme l'une de ses sources de modèles prises en charge, aux côtés de sa propre galerie, de Hugging Face et des configs YAML
  • La surface de configuration d'Ollama est volontairement minimale ; LocalAI expose davantage de configuration (choix du backend, configs YAML de modèles, plusieurs cibles de déploiement) en échange de ce périmètre plus large

Comment LocalAI se compare-t-il à llama.cpp et vLLM ?

LocalAI n'est pas un moteur d'inférence brut concurrent de llama.cpp ou vLLM — son architecture documentée charge les deux comme backends interchangeables pour la génération de texte, aux côtés de backends séparés pour l'image et l'audio.

llama.cpp

Rôle:
Un moteur d'inférence texte adapté au CPU/GPU ; l'un des backends texte que LocalAI peut charger.
Articles sur llama.cpp (10)

+167 autres non affichés

vLLM

Rôle:
Un moteur de serving GPU à haut débit ; documenté comme un autre backend texte que LocalAI peut charger.
Articles sur vLLM (10)

+84 autres non affichés

LocalAI

Rôle:
La couche de routage et de compatibilité API au-dessus de ces backends, ajoutant des backends image, audio et embedding en plus du texte.
Articles sur LocalAI (9)

+8 autres non affichés

Choisir entre ces projets n'est généralement pas un « soit l'un soit l'autre » — un déploiement LocalAI peut faire tourner llama.cpp ou vLLM en interne pour ses requêtes texte. La décision porte sur le fait de s'adresser directement à ce moteur (llama.cpp, vLLM) ou via une couche API multimodale plus large capable aussi de router des requêtes image et audio (LocalAI).

À qui s'adresse LocalAI ?

LocalAI convient à ceux qui veulent une seule surface d'API auto-hébergée couvrant plusieurs modalités, pas à ceux qui cherchent simplement le chemin le plus rapide vers un unique modèle de texte sur leur propre machine.

Utiliser LocalAI si

  • Un seul serveur auto-hébergé doit couvrir texte, génération d'image et audio (transcription et synthèse vocale) derrière une API compatible OpenAI unique
  • Du code applicatif existe déjà contre les API OpenAI, Anthropic ou ElevenLabs et doit pointer vers une infrastructure auto-hébergée avec un minimum de changements
  • La flexibilité de changer le backend texte sous-jacent (llama.cpp, vLLM) sans réécrire le code d'appel API est recherchée
  • Docker et une configuration YAML de base pour les backends et modèles ne posent pas de problème

Éviter LocalAI si

  • Seul un chat texte rapide et minimal, mono-utilisateur, sur sa propre machine est nécessaire — Ollama ou LM Studio ont une surface de configuration plus réduite pour ce cas précis
  • Le débit GPU maximal possible pour le texte seul est prioritaire — s'adresser directement à vLLM évite une couche de routage supplémentaire
  • Une application de bureau graphique sans configuration est préférée à un serveur auto-hébergé à configurer et maintenir

LocalAI vs. alternatives en un coup d'œil

Ces outils se recoupent par endroits mais diffèrent par leur périmètre et l'effort de mise en place.

LocalAI

Périmètre:
Texte, image, audio, embeddings via backends interchangeables. Docker, installeur macOS ou binaire CLI.
Idéal pour:
Une seule API auto-hébergée, multimodale, compatible OpenAI/Anthropic/ElevenLabs.
Articles sur LocalAI (9)

+8 autres non affichés

Ollama

Périmètre:
Surtout des modèles de texte (et un peu de vision). Installation et téléchargement de modèle en une commande.
Idéal pour:
Le chemin le plus rapide vers un modèle de texte local mono-utilisateur.
Articles sur Ollama (10)

+310 autres non affichés

llama.cpp

Périmètre:
Moteur d'inférence texte pour CPU et GPU. CLI, interface web et serveur compatible OpenAI.
Idéal pour:
Contrôle direct au niveau moteur sur l'inférence texte — souvent le backend sous Ollama et LocalAI.
Articles sur llama.cpp (10)

+167 autres non affichés

vLLM

Périmètre:
Bibliothèque de serving texte GPU à haut débit. Paquet Python, serveur compatible OpenAI.
Idéal pour:
Débit GPU concurrent maximal pour le texte seul.
Articles sur vLLM (10)

+84 autres non affichés

Cet article n'a pas fait de benchmark indépendant de ces outils les uns contre les autres et n'affirme pas la supériorité technique de l'un d'eux — la comparaison ne couvre que des faits documentés de périmètre, de configuration et d'architecture.

Comparer dans l'annuaire

Que ne couvre pas cet article ?

Il s'agit d'un article explicatif construit à partir de la documentation publique et du dépôt de LocalAI, pas d'un benchmark ou d'un audit de sécurité réalisé en pratique.

  • Aucune comparaison de débit, de latence ou de qualité de sortie mesurée indépendamment face à Ollama, llama.cpp ou vLLM — cela dépend du backend et du modèle configurés dans LocalAI, ainsi que du matériel
  • Aucune liste exhaustive de chaque backend pris en charge par le projet — l'écosystème de backends évolue dans le temps ; la galerie et la documentation propres au projet font foi pour la couverture actuelle
  • Aucun audit de sécurité ligne par ligne du code — il est open-source et sous licence MIT, le code source est donc disponible pour un examen indépendant
  • Aucune couverture de chaque cible de déploiement (manifestes Kubernetes, configurations spécifiques au cloud) — cet article se concentre sur les chemins Docker et CLI que la plupart des self-hosters essaient en premier
  • Aucune vérification indépendante des fonctionnalités multi-utilisateurs ou entreprise (clés API, quotas, authentification) au-delà de ce que documente le projet — vérifier les capacités actuelles auprès de la documentation officielle avant d'en dépendre pour un contrôle d'accès en production

Erreurs fréquentes en essayant LocalAI

La plupart des frictions avec LocalAI viennent du fait de le traiter comme un moteur unique et figé plutôt que comme un routeur devant des backends séparés.

Erreur 1 : s'attendre à ce qu'un backend couvre toutes les modalités

Les capacités texte, image et audio de LocalAI proviennent chacune d'un backend différent qui doit être installé pour que cette modalité fonctionne. Installer LocalAI seul ne rend pas automatiquement toutes les modalités disponibles — le backend et le modèle pertinents doivent d'abord être installés.

Erreur 2 : supposer que « sans GPU requis » signifie que tout modèle tourne vite sur CPU

Le fait que le support CPU seul soit entièrement documenté ne signifie pas que toute taille de modèle tourne rapidement sans GPU — les modèles plus grands profitent toujours de l'accélération GPU, exactement comme sous llama.cpp ou vLLM directement, puisque LocalAI délègue le travail d'inférence réel à ces moteurs.

Erreur 3 : confondre LocalAI avec des applications « Local AI » sans rapport

« Local AI » et « LocalAI » sont utilisés comme termes descriptifs génériques par de nombreux produits sans rapport entre eux. Vérifier qu'il s'agit bien de github.com/mudler/LocalAI avant de suivre des instructions d'installation, car les noms à consonance générique pour des outils d'IA locale sont courants et ne sont pas tous liés à ce projet.

Questions fréquemment posées

Qu'est-ce que LocalAI ?

LocalAI est un moteur d'IA gratuit, sous licence MIT et auto-hébergé, créé par Ettore Di Giacinto ("mudler"), qui expose une API compatible OpenAI devant des backends interchangeables pour des modèles de texte, d'image et audio.

LocalAI est-il gratuit ?

Oui. LocalAI est un logiciel gratuit et open-source publié sous licence MIT, sans abonnement ni compte requis pour l'auto-héberger.

LocalAI a-t-il besoin d'un GPU ?

Non — LocalAI est documenté comme fonctionnant uniquement sur CPU sans GPU requis. Des images Docker accélérées GPU distinctes sont aussi publiées pour le matériel NVIDIA CUDA, AMD ROCm, Intel et Vulkan.

LocalAI est-il la même chose que llama.cpp ?

Non. llama.cpp est un moteur d'inférence texte ; LocalAI est une couche de routage et de compatibilité API qui peut charger llama.cpp (ou vLLM, ou d'autres moteurs) comme l'un de ses backends, tout en ajoutant des backends image et audio.

LocalAI est-il meilleur qu'Ollama ?

« Meilleur » dépend du périmètre : Ollama est un outil plus simple et plus étroit, centré surtout sur les modèles de texte avec une configuration minimale, tandis que LocalAI couvre un ensemble plus large de modalités (texte, image, audio) derrière une API, en échange de plus de configuration.

Quelles API LocalAI prend-il en charge ?

LocalAI documente une compatibilité en remplacement direct avec l'API OpenAI, plus des points de terminaison compatibles Anthropic et ElevenLabs, si bien que du code client existant pour ces API fonctionne souvent contre une instance LocalAI auto-hébergée avec un simple changement d'URL de base.

LocalAI peut-il générer des images et transcrire de l'audio, pas seulement discuter ?

Oui. Les backends documentés de LocalAI incluent des backends basés sur diffusers pour la génération d'image et des backends basés sur whisper.cpp pour la transcription, aux côtés de backends de synthèse vocale et d'embedding.

LocalAI a-t-il un lien avec l'application mobile « Loci » ?

Non. Loci est une application mobile distincte et sans rapport pour le chat hors ligne sur l'appareil. LocalAI est le projet de serveur auto-hébergé sur github.com/mudler/LocalAI, sans code, société ou lien commun avec Loci.

Quel port LocalAI utilise-t-il par défaut ?

LocalAI écoute par défaut sur le port 8080 lorsqu'il est lancé via ses images Docker documentées.

D'où LocalAI peut-il obtenir ses modèles ?

Le projet documente plusieurs sources de modèles : sa propre galerie installable, des dépôts Hugging Face, des références au format Ollama, des URL de configuration YAML directes et des images OCI.

Sources

← Retour aux LLM locaux avancés

MCP