# LocalAI — votre API IA compatible OpenAI, en local

LocalAI : héberger une API compatible OpenAI en local (texte, image, voix) avec Docker. Architecture modulaire, licence MIT, sécurité de l'API et sources.

URL canonique : https://www.osfria.fr/localai.html

---

OSIALab · Moteur & API locale

## LocalAI — votre API IA compatible OpenAI, en local

LocalAI expose sur votre propre machine une API compatible avec celle d'OpenAI — texte, image, voix, transcription — sans clé cloud ni abonnement. Vos applications qui parlent à ChatGPT pointent vers **votre infrastructure**, et les données ne quittent pas votre réseau.

### Fiabilité & transparence

🟢 **Fiable et activement maintenu**

- **Maintenance** : v4.3.0 publiée en mai 2026, v4.2.0 en mai 2026, v4.1.0 en avril 2026 — rythme mensuel très soutenu ; le projet évolue vers une plateforme IA multi-modale complète (voix, vidéo, vision, cluster distribué).
- **Adoption** : référence pour l'auto-hébergement d'une API compatible OpenAI multi-modale ; utilisé en production dans des contextes d'équipe et de serveur.
- **Sécurité** : aucune faille majeure connue sur le logiciel lui-même. Le point critique reste l'exposition réseau : l'API n'a pas d'authentification par défaut — à restreindre à localhost ou à protéger par reverse-proxy. Depuis la v4.1+, une clé API et une attribution par utilisateur sont disponibles.
- **Verdict** : utilisable pour construire un « OpenAI privé » sur son infrastructure, par un profil avancé à l'aise avec Docker et YAML. Non adapté à un déploiement exposé sans protection réseau sérieuse.

> Page informative, sans valeur de conseil. Téléchargez depuis la **source officielle**, vérifiez la **licence** du logiciel *et* de chaque modèle, et gardez en tête qu'un modèle de langage **peut se tromper** : croisez les informations importantes.

### À quoi ça sert

LocalAI (projet de **mudler**, Ettore Di Giacinto) est un serveur d'inférence open source qui reproduit l'API REST d'OpenAI. Il ne se limite pas au texte : il couvre aussi la **génération d'images**, la **transcription** et la **synthèse vocale**, le tout en local. L'intérêt central : brancher des outils existants — [LibreChat](https://www.osfria.fr/librechat.html), [n8n](https://www.osfria.fr/n8n.html), [Continue](https://www.osfria.fr/continue.html)… — sur vos propres modèles, simplement en changeant l'URL de l'API. C'est, en somme, un **OpenAI privé** que vous hébergez.

### Ce qui fait sa force

- **Un seul point d'accès pour tout.** Texte, vision, audio, images : LocalAI rassemble plusieurs modalités derrière la même API compatible OpenAI. Un outil prévu pour `api.openai.com` fonctionne en pointant vers LocalAI, *sans réécrire le code*.
- **Une architecture modulaire par backends.** Depuis 2025, LocalAI sépare le cœur des moteurs : chaque **backend** (llama.cpp, vLLM, whisper.cpp, stable-diffusion, MLX…) est un service **gRPC** isolé, distribué comme image OCI. On installe, met à jour ou retire un moteur sans toucher au reste, et une panne dans l'un ne fait pas tomber les autres. On peut même écrire son propre backend.
- **Pas de GPU obligatoire.** LocalAI tourne sur processeur (via llama.cpp et les modèles GGUF) et exploite le GPU si vous en avez un, avec des images dédiées CUDA, ROCm ou Intel.
- **Local et privé par construction.** Avec vos propres modèles, aucune donnée ne sort de votre réseau. C'est précisément ce qui le distingue d'une API cloud : la compatibilité d'OpenAI, sans OpenAI.
- **Open source sous licence MIT.** Permissive et claire : le code est auditable et l'usage, y compris commercial, est libre côté logiciel (chaque *modèle* garde sa propre licence).

### Pour qui

LocalAI s'adresse à un profil **avancé**, à l'aise avec Docker, les fichiers YAML et la ligne de commande. Si vous voulez seulement lancer un modèle pour discuter, [Ollama](https://www.osfria.fr/ollama.html) est plus direct. LocalAI prend tout son sens quand vous voulez **une API stable et multi-modale** à brancher sur plusieurs applications — un petit OpenAI maison pour votre poste, votre serveur ou votre réseau d'équipe.

### Installation

#### Prérequis

La voie la plus simple est **Docker**. Un GPU est optionnel mais accélère nettement l'inférence (images dédiées disponibles).

#### Lancer LocalAI avec Docker

Démarrage de base, en écoute sur le port 8080, avec un dossier local pour les modèles :

```
docker run -p 8080:8080 \
  -v $(pwd)/models:/models \
  localai/localai:latest
```

Le dossier `./models` contient vos fichiers (GGUF pour le backend llama.cpp) et la configuration associée. LocalAI charge ce qui s'y trouve au démarrage.

#### Décrire un modèle (fichier YAML)

Placez un GGUF dans `models/`, puis un fichier de configuration du même nom :

```
# models/mistral.yaml
name: mistral
backend: llama-cpp
parameters:
  model: mistral-7b-instruct.Q4_K_M.gguf
```

#### Vérifier que l'API répond

```
# Lister les modèles disponibles
curl http://localhost:8080/v1/models

# Envoyer une requête de complétion (format OpenAI)
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral",
    "messages": [{"role": "user", "content": "Bonjour !"}]
  }'
```

#### Avec GPU NVIDIA

```
docker run --gpus all -p 8080:8080 \
  -v $(pwd)/models:/models \
  localai/localai:latest-gpu-nvidia-cuda-12
```

### Points de vigilance

Le cœur du sujet avec LocalAI n'est pas l'outil lui-même (sain et local par défaut) mais le fait qu'il **expose une API** : la question clé est de savoir *qui* peut l'atteindre.

| Point d'attention | Niveau | Ce qu'il faut savoir |
| --- | --- | --- |
| API exposée sur le réseau sans authentification | 🔴 élevé si exposée | Par défaut, l'API n'a pas d'authentification. Dans le conteneur elle écoute sur toutes les interfaces ; **publiez le port avec prudence**. Limitez la publication à `127.0.0.1:8080` (`-p 127.0.0.1:8080:8080`) ou placez un reverse-proxy authentifié devant. LocalAI sait aussi exiger une clé d'API. |
| Licence du modèle (≠ celle de LocalAI) | 🟡 selon le modèle | LocalAI est sous **MIT**, mais chaque modèle chargé a sa propre licence. Lisez-la avant tout usage professionnel ou commercial. |
| Backends à installer selon les usages | 🟢 faible | L'architecture modulaire (backends gRPC en images OCI) implique d'ajouter le moteur correspondant à chaque modalité (vLLM, whisper.cpp, stable-diffusion…). C'est de la configuration, pas un risque ; prévoyez l'espace disque des images. |

### Sécurité

- **Restreindre l'écoute.** Publiez le port sur la boucle locale (`-p 127.0.0.1:8080:8080`) tant que vous n'avez pas besoin d'un accès distant.
- **Authentifier l'accès distant.** Pour un usage en équipe, activez la clé d'API de LocalAI et/ou placez un reverse-proxy avec authentification et TLS (Caddy, Nginx, Traefik).
- **Mettre à jour l'image Docker** régulièrement : les correctifs arrivent avec les nouvelles versions.
- **Télécharger les modèles depuis des sources fiables** (Hugging Face, dépôts officiels).

### Aller plus loin

- [Ollama](https://www.osfria.fr/ollama.html) — plus direct pour lancer un modèle sans configuration YAML.
- [LibreChat](https://www.osfria.fr/librechat.html) — interface de chat à brancher sur l'API de LocalAI.
- [Open WebUI](https://www.osfria.fr/open-webui.html) — interface web compatible via l'API OpenAI de LocalAI.
- [LiteLLM](https://www.osfria.fr/litellm.html) — passerelle unifiée, complémentaire pour router plusieurs providers.
- [OSIALab](https://www.osfria.fr/osialab.html) — comparer LocalAI avec les autres moteurs locaux.

### Sources

- Code source & licence (MIT) : [github.com/mudler/LocalAI](https://github.com/mudler/LocalAI)
- Documentation : [localai.io](https://localai.io)
- Images Docker : [hub.docker.com/r/localai/localai](https://hub.docker.com/r/localai/localai)